GNU   davin.50webs.com/research
Bringing to you notes for the ages

       Main Menu          Research Projects         Photo Album            Curriculum Vitae      The Greatest Artists
    Email Address       Computer Games          Web Design          Java Training Wheels      The Fly (A Story)   
  Political Activism   Bob Dylan Quotes+       My Life Story          Smoking Cessation          Other Links      
Debugging Macros     String Class I     Linked List System I Java for C Programmers Naming Convention
    String Class II         How I use m4              Strings III                 Symmetrical I/O             Linked Lists II     
Run-Time Type Info   Virtual Methods      An Array System        Science & Religion            Submodes       
  Nested Packages      Memory Leaks    Garbage Collection      Internet & Poverty      What is Knowledge?
Limits of Evolution   Emacs Additions      Function Plotter           Romantic Love        The Next Big Thing
    Science Fiction     Faster Compilation Theory of Morality         Elisp Scoping               Elisp Advice      
  S.O.G.M. Pattern       Safe Properties         School Bullying          Charisma Control          Life and Death    
     Splitting Java          Multiple Ctors       Religious Beliefs         Conversation 1           Conversation 2    
   J.T.W. Language    Emacs Additions II      Build Counter             Relation Plotter          Lisp++ Language  
  Memory Leaks II   Super Constructors CRUD Implementation Order a Website Form There Is An Afterlife
More Occam's Razor C to Java Translator Theory of Morality II


d-latexize7.el

    

;;; d-latexize.el

;; Copyright (C) 2014-2015 Davin Pearson

;; Emacs Lisp Archive Entry
;; Filename: d-latexize.el
;; Author/Maintainer: Davin Max Pearson <http://davin.50webs.com>
;; Keywords: LaTeX-ize functionality
;; Version: 1.0

;;; Commentary:

;; This file is not part of GNU Emacs.
;;
;; The file fontifies different code buffers into LaTeX's
;; \color{COLOUR}{...} and \colorbox{COLOUR}{...} format for
;; fontification.

;;; Limitation of Warranty


;; This program is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or (at
;; your option) any later version.
;;
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
;; General Public License for more detail.
;;
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs, see the file COPYING.  If not, see:
;;
;; <http://www.gnu.org/licenses/gpl-3.0.txt>.


;;; Install Instructions:

;; See the following URL for the latest info and a tarball:
;;
;; <http://davin.50webs.com/research/2010/mopa2e2.html#d-latexize7>
;;
;; Then untar the tarball to a folder pointed to by the Emacs variable
;; load-path and add the following line to your ~/.emacs file.
;;
;; (require 'd-latexize7)

;;; Known Bugs:

;; None so far!

;;; Code:

(if (not (string-match "~www/dlisp/" (car load-path)))
  (setq load-path (cons "~www/dlisp/" load-path)))

(if noninteractive
    (load-file (concat (car load-path) "diagnose.el")))

(require 'lisp++-mode)
(require 'tes-mode)

;;;(CXXCOMM);; (d-latexize--inside-comment)(CXXMMOC)
(defun d-latexize--inside-comment ()
  (save-excursion
    (save-match-data
      (let ((p (point)))
        (when (re-search-backward "(7cxxcomm)" nil t)
          (when (re-search-forward "(7cxxmmoc)" nil t)
            (> (point) p)))))))

(defun d-latexize--inside-string ()
  (save-excursion
    (save-match-data
      (let ((p (point)))
        (when (re-search-backward "(7cxxstri)" nil t)
          (when (re-search-forward "(7cxxirts)" nil t)
            (> (point) p)))))))

(defun d-latexize--inside-func ()
  (save-excursion
    (save-match-data
      (let ((p (point)))
        (when (re-search-backward "(7cxxfunc)" nil t)
          (when (re-search-forward "(7cxxcnuf)" nil t)
            (> (point) p)))))))

(defun d-latexize--inside-hash ()
  (save-excursion
    (save-match-data
      (let ((p (point)))
        (when (re-search-backward "(7cxxhash)" nil t)
          (when (re-search-forward "(7cxxhsah)" nil t)
            (> (point) p)))))))

(defun d-latexize--inside-prvt ()
  (save-excursion
    (save-match-data
      (let ((p (point)))
        (when (re-search-backward "(7cxxprvt)" nil t)
          (when (re-search-forward "(7cxxtvrp)" nil t)
            (> (point) p)))))))

(defun d-latexize--inside-glbl ()
  (save-excursion
    (save-match-data
      (let ((p (point)))
        (when (re-search-backward "(7cxxglbl)" nil t)
          (when (re-search-forward "(7cxxlblg)" nil t)
            (> (point) p)))))))

(defun d-latexize--inside-jtw ()
  (save-excursion
    (save-match-data
      (let ((p (point)))
        (when (re-search-backward "(7cxxjtw)" nil t)
          (when (re-search-forward "(7cxxwtj)" nil t)
            (> (point) p)))))))

(defun d-latexize--inside-clss ()
  (save-excursion
    (save-match-data
      (let ((p (point)))
        (when (re-search-backward "(7cxxclss)" nil t)
          (when (re-search-forward "(7cxxsslc)" nil t)
            (> (point) p)))))))

(defun d-latexize--inside-vari ()
  (save-excursion
    (save-match-data
      (let ((p (point)))
        (when (re-search-backward "(7cxxvari)" nil t)
          (when (re-search-forward "(7cxxirav)" nil t)
            (> (point) p)))))))

(defun d-latexize--inside-grnc ()
  (save-excursion
    (save-match-data
      (let ((p (point)))
        (when (re-search-backward "(7cxxgrnc)" nil t)
          (when (re-search-forward "(7cxxcnrg)" nil t)
            (> (point) p)))))))

(defun d-latexize--inside-redc ()
  (save-excursion
    (save-match-data
      (let ((p (point)))
        (when (re-search-backward "(7cxxredc)" nil t)
          (when (re-search-forward "(7cxxcder)" nil t)
            (> (point) p)))))))

(defun d-latexize--inside-numb ()
  (save-excursion
    (save-match-data
      (let ((p (point)))
        (when (re-search-backward "(7cxxnumb)" nil t)
          (when (re-search-forward "(7cxxbmun)" nil t)
            (> (point) p)))))))

(defun d-latexize--inside-comment-or-string ()
  (save-match-data
    (or (d-latexize--inside-comment)
        (d-latexize--inside-string)
        (d-latexize--inside-func)
        (d-latexize--inside-hash)
        (d-latexize--inside-prvt)
        (d-latexize--inside-glbl)
        (d-latexize--inside-jtw)
        (d-latexize--inside-clss)
        (d-latexize--inside-vari)
        (d-latexize--inside-grnc)
        (d-latexize--inside-redc)
        (d-latexize--inside-numb)
        )))

(defun d-latexize--inside-main ()
  (save-excursion
    (save-match-data
      (let ((p (point)))
        (when (re-search-backward "(cname main)" nil t)
          (beginning-of-line)
          (forward-sexp 1)
          (> (point) p))))))

(defun checkpoint (&rest args) (message "*** checkpoint %s" args))

;; (d-goto-char-safe -5)
;; (d-goto-char-safe (+ (point-max) 5))
(defun d-goto-char-safe (p)
  "Safely goto char, clamps to within the range (point-min) ... (point-max)"
  (goto-char (min (max (point-min) p) (point-max))))

(defun d-looking-at-7cxx (p)
  (save-excursion
    (save-match-data
      (goto-char p)
      (skip-chars-forward " \t")
      (looking-at "(7cxx")
      )
    )
  )

(defun doit ()
  (interactive)
  (let ((case-fold-search nil)
        (debug-on-error t) str str1 str2)

    (let ((mode-emacs-lisp nil)
          (mode-lisp++     nil)
          (mode-java       nil)
          (mode-c++        nil)
          (mode-m4         nil)
          (str             nil))

      (setq d-face-super-comment 'd-face-super-comment)
      (checkpoint "checkpoint:1")

      (when (or (not (boundp '*target*)) (not *target*))
        ;;(setq *target* "d:/home/c++-projects/lisp++2c++-lisp++2c++.el")
        ;;(setq *target* "/media/C1TB/home/c++-projects/lisp++2c++-cclass.el")
        ;;(setq *target* "d:/home/c++-projects/2012/Arithmetickles/arithmetickles.lisp++")
        ;;(setq *target* "~/c++-projects/2012/Arithmetickles/glyph_a.lisp++")
        (setq *target* "~/lisp++-projects/2012/cpause/my_time_sharing_system.h++")
        ;;(setq *target* "~/lisp++-projects/2006/libd/ptr.hh")
        ;;(setq *target* "~/book/foo.hh")
        ;;(setq *target* "~/book/foo.lisp++")
        ;;(setq *target* "~/book/foo.el")
        )

      (checkpoint "checkpoint:2")

      (assert (boundp '*target*))
      (assert *target*)
      (message "*** d-latexize found file=\"%s\"" *target*)
      (assert (not (string= "" *target*)))

      (checkpoint "checkpoint:3")

      ;;(message "**** *target*=%s" *target*)

      (if (string-match "\\.m4$" *target*)
          (setq mode-m4 t))

      (if (string-match "\\.el$" *target*)
          (setq mode-emacs-lisp t))

      (if (string-match "\\.lisp\\+\\+$" *target*)
          (setq mode-lisp++ t))

      (if (or (string-match "\\.c$" *target*)
              (string-match "\\.h$" *target*)
              (string-match "\\.hh$" *target*)
              (string-match "\\.ch$" *target*)
              (string-match "\\.cc$" *target*)
              (string-match "\\.h\\+\\+$" *target*)
              (string-match "\\.ch\\+\\+$" *target*)
              (string-match "\\.c\\+\\+$" *target*))
          (setq mode-c++ t))

      (if (string-match "\\.java$" *target*)
          (setq mode-java t))

      (checkpoint "checkpoint:4")

      (setq *buf* (find-file *target*))
      (assert (> (point-max) 0))
      (read-only-mode -1)
      (assert (or mode-emacs-lisp mode-lisp++ mode-c++ mode-java mode-m4))

      (when mode-emacs-lisp
        (message "mode-emacs-lisp")
        (emacs-lisp-mode))
      (when mode-lisp++
        (message "mode-lisp++")
        (lisp++-mode))
      (when mode-c++
        (message "mode-c++")
        (c++-mode))
      (when mode-java
        (message "mode-java")
        (java-mode))
      (when mode-m4
        (message "mode-m4")
        (tes-mode))
      )

    (checkpoint "checkpoint:5")

    (setq str-variable1234-no-space (concat
                                     "\\<\\(\\(signed[ \t]+\\|unsigned[ \t]+"
                                     "\\|const[ \t]+\\)*"
                                     "\\(dmp::\\|std::\\)?"
                                     "\\(void\\|bool\\|char\\|short\\|int\\|long"
                                     "\\|float\\|double"
                                     "\\|safe_bool\\|safe_int\\|"
                                     "\\|string\\|string_buffer"
                                     "\\|m?ptr< ?[A-Z][a-zA-Z0-9_<,]*[ >]*"
                                     "\\|[A-Z]+[a-z][a-zA-Z0-9_<,]*[ >]*"
                                     "\\|[A-Z][0-9]?"
                                     "\\|BITMAP\\|RLE_SPRITE\\|SAMPLE"
                                     "\\)[ \t]*[&*]*[ \t]*\\)"
                                    ))

    (setq str-variable1234-yes-space (concat
                                      "\\<\\(\\(signed[ \t]+\\|unsigned[ \t]+"
                                      "\\|const[ \t]+\\)*"
                                      "\\(dmp\\|std\\)?"
                                      "\\(void\\|bool\\|char\\|short\\|int\\|long"
                                      "\\|float\\|double"
                                      "\\|safe_bool\\|safe_int\\|"
                                      "\\|string\\|string_buffer"
                                      "\\|m?ptr<[A-Z][a-zA-Z0-9_<,]*[ >]*"
                                      "\\|[A-Z]+[a-z][a-zA-Z0-9_<,]*[ >]*"
                                      "\\|[A-Z][0-9]?"
                                      "\\|BITMAP\\|RLE_SPRITE\\|SAMPLE"
                                      "\\)[ \t]*[&*]*[ \t]+\\)"
                                      ))

    (checkpoint "checkpoint:6")

    (when (or (eq major-mode 'lisp++-mode)
              (eq major-mode 'emacs-lisp-mode))
      (set-syntax-table (copy-syntax-table))
      (modify-syntax-entry ?- "w")
      (modify-syntax-entry ?_ "w")
      )

    (checkpoint "checkpoint:7")

    (condition-case err
        (progn
          (goto-char (point-min))
          (while (re-search-forward "{" nil t)
            (replace-match "(2zz){" 'fixedcase)
            ))
      (error (message "Error 7! err=%s" err)))

    (checkpoint "checkpoint:8")

    (condition-case err
        (progn
          (goto-char (point-min))
          (while (re-search-forward "}" nil t)
            (replace-match "(2zz)}" 'fixedcase)
            ))
      (error (message "Error 8! err=%s" err)))

    (checkpoint "checkpoint:9")

    (condition-case err
        (progn
          (goto-char (point-min))
          (while (re-search-forward "\\$" nil t)
            (replace-match "(2zz)$" 'fixedcase)
            ))
      (error (message "Error 9! err=%s" err)))

    (checkpoint "checkpoint:10")

    (condition-case err
        (progn
          (goto-char (point-min))
          (while (re-search-forward "" nil t) ;;                                                  1         2         3         4         5         6         7         8
            (replace-match "\n{(2zz)colorbox{red}{(2zz)color{white}{(2zz)bf{^(7cxxllll)(2zz)phantom{01234567890123456789012345678901234567890123456789012345678901234567890123456789}}}}}\n" 'fixedcase)
            ))
      (error (message "Error 10! err=%s" err)))

    (checkpoint "checkpoint:10c")

    (condition-case err
        (when (eq major-mode 'emacs-lisp-mode)
          (goto-char (point-min))
          (while (re-search-forward "\\(^\\|[^;]\\);;[^;]" nil t)
            (save-excursion
              (d-goto-char-safe (- (point) 3))
              (skip-chars-backward " \t")
              (insert "(7cxxcomm){(2zz)color{comm}{")
              (end-of-line)
              (insert "}}(7cxxmmoc)"))))
      (error (message "Error 10c! err=%s" err)))

    (checkpoint "checkpoint:11")

    (condition-case err
        (when (eq major-mode 'emacs-lisp-mode)
          (goto-char (point-min))
          (while (and (re-search-forward ";;;" nil t)
                      (not (d-latexize--inside-comment)))
            (save-excursion
              (d-goto-char-safe (- (point) 3))
              (skip-chars-backward " \t")
              (insert "(7cxxcomm){(2zz)bf(2zz)color{red}{")
              ;;(end-of-line)
              (forward-line 1)
              (beginning-of-line)
              ;; (d-latexize--inside-comment) => t
              (insert "}}(7cxxmmoc)"))))
      (error (message "Error 11! err=%s" err)))

    (checkpoint "checkpoint:12")

    (condition-case err
        (when (or (eq major-mode 'c++-mode)
                  (eq major-mode 'java-mode)
                  (eq major-mode 'lisp++-mode))
          (goto-char (point-min))
          (while (re-search-forward "\\(^\\|[^/]\\)//[^/]" nil t)
            (save-excursion
              (d-goto-char-safe (- (point) 3))
              (skip-chars-backward " \t")
              (insert "(7cxxcomm){(2zz)color{comm}{")
              (end-of-line)
              (insert "}}(7cxxmmoc)")
              )))
      (error (message "Error 12! err=%s" err)))

    (checkpoint "checkpoint:13")

    (condition-case err
        (when (or (eq major-mode 'c++-mode)
                  (eq major-mode 'java-mode)
                  (eq major-mode 'lisp++-mode))
          (goto-char (point-min))
          (while (and (re-search-forward "///" nil t)
                      (not (d-latexize--inside-comment)))
            (d-goto-char-safe (- (point) 3))
            (skip-chars-backward " \t")
            (insert "(7cxxcomm){(2zz)bf(2zz)color{red}{")
            (end-of-line)
            (insert "}}(7cxxmmoc)")))
      (error (message "Error 13! err=%s" err)))

    (checkpoint "checkpoint:14")

    (condition-case err
        (when (or (eq major-mode 'c++-mode)
                  (eq major-mode 'java-mode)
                  (eq major-mode 'lisp++-mode))
          (goto-char (point-min))
          (while (re-search-forward "/\\*\\*" nil t)
            (save-excursion
              (d-goto-char-safe (- (point) 2))
              (when t ;;(not (d-latexize--inside-comment))
                (skip-chars-backward " \t")
                (insert "(7cxxcomm){(2zz)bf(2zz)color{red}{")
                (re-search-forward "*/")
                (insert "}}(7cxxmmoc)")))))
      (error (message "Error 14! err=%s" err)))

    (checkpoint "checkpoint:15")

    (condition-case err
        (when (or (eq major-mode 'c++-mode)
                  (eq major-mode 'java-mode)
                  (eq major-mode 'lisp++-mode))
          (goto-char (point-min))
          (while (and (re-search-forward "/\\*" nil t)
                      (not (d-latexize--inside-comment)))
            (save-excursion
              (d-goto-char-safe (- (point) 2))
              (skip-chars-backward " \t")
              (insert "(7cxxcomm){(2zz)color{comm}{")
              (re-search-forward "*/")
              (insert "}}(7cxxmmoc)"))))
      (error (message "Error 15! err=%s" err)))

    (checkpoint "checkpoint:15b")

    (condition-case err
        (when (eq major-mode 'c++-mode)
          (goto-char (point-min))
          (while (re-search-forward "^\\([ \t]*\\)\\(#include[ \t]+\\)\\(<.+>\\|\".+\"\\)" nil t)
            (if (and (not (d-latexize--inside-comment))
                     (not (d-latexize--inside-hash)))
                (replace-match "\\1(7cxxhash){(2zz)colorbox{incl}{#include}} {(2zz)color{white}{(2zz)colorbox{string-blue}{(2zz)bf{\\3}}}}(7cxxhsah)" 'fixedcase)
              )))
      (error (message "Error 15b! err=%s" err)))


;;; #include "../../2006/libd/libd.hh"
    (checkpoint "checkpoint:15c")

    (condition-case err
        (when (eq major-mode 'c++-mode)
          (goto-char (point-min))
          (while (re-search-forward "^\\([ \t]*\\)\\(#endif\\)" nil t)
            (if (and (not (d-latexize--inside-comment))
                     (not (d-latexize--inside-hash)))
                (replace-match "\\1(7cxxhash){(2zz)colorbox{incl}{#endif}}(7cxxhsah)" 'fixedcase)
              )))
      (error (message "Error 15c! err=%s" err)))

    (checkpoint "checkpoint:15d")

    (condition-case err
         (when (eq major-mode 'c++-mode)
           (goto-char (point-min))
           (while (re-search-forward "^[ \t]*\\(#[a-z]+\\)[ \t]+\\([a-zA-Z_][A-Za-z0-9_]*\\)(" nil t)
             (if (and (not (d-latexize--inside-comment))
                      (not (d-latexize--inside-hash)))
                 (replace-match "(7cxxhash){(2zz)colorbox{incl}{\\1}} {(2zz)colorbox{func}{\\2}}(7cxxhsah)(" 'fixedcase)
               )))
       (error (message "Error 15d! err=%s" err)))

     (checkpoint "checkpoint:15e")

     (condition-case err
         (when (eq major-mode 'c++-mode)
           (goto-char (point-min))
           (while (re-search-forward "^[ \t]*\\(#[a-z]+\\)[ \t]+\\([a-zA-Z_][A-Za-z0-9_]*\\)" nil t)
             (if (and (not (d-latexize--inside-comment))
                      (not (d-latexize--inside-hash)))
                 (replace-match "(7cxxhash){(2zz)colorbox{incl}{\\1}} {(2zz)color{vari}{\\2}}(7cxxhsah)" 'fixedcase)
               )))
       (error (message "Error 15e! err=%s" err)))

    (checkpoint "checkpoint:16")

    (condition-case err
        (progn
          (goto-char (point-min))
          (while (re-search-forward (concat "\\([^\\]\\)\\('\\(\\\\\\\\\\|"
                                            "\\\\n\\|\\\\r\\|\\\\t\\|"
                                            "[^'\"\\\r\n\t]\\)'\\)") nil t)
            (if (and (not (d-latexize--inside-comment))
                     (not (d-latexize--inside-hash)))
                (replace-match "\\1(7cxxstri){(2zz)bf(2zz)colorbox{string-blue}{(2zz)color{white}{\\2}}}(7cxxirts)" 'fixedcase)
              )))
      (error (message "Error 16! err=%s" err)))

    (checkpoint "checkpoint:17")

    (condition-case err
        (progn
          (goto-char (point-min)) ;;                            12345678
          (while (re-search-forward (concat "\\([^\\]\\)\\(\"\\(\\\\\\\\\\|"
                                            "\\\\^\\|\\\\\'\\|\\\\\"\\|\\\\[0-3][0-7][0-7]\\|"
                                            "\\\\0\\|\\\\t\\|\\\\r\\|\\\\n\\|"
                                            "\\\\$\\|[^\"\\\r\n\t]\\)*\"\\)") nil t)
            (if (and (not (d-latexize--inside-comment))
                     (not (d-latexize--inside-hash)))
                (replace-match "\\1(7cxxstri){(2zz)bf(2zz)colorbox{string-blue}{(2zz)color{white}{\\2}}}(7cxxirts)" 'fixedcase)
              )))
      (error (message "Error 17! err=%s" err)))

    (checkpoint "checkpoint:17b")

    (condition-case err
        (when (string-match "\\.m4$" *target*)
          (goto-char (point-min))
          (while (re-search-forward "(2zz)$[0-9]+" nil t)
            (if (not (d-latexize--inside-comment-or-string))
                (replace-match "(7cxxnumb){(2zz)color{numb}{\\&}}(7cxxbmun)" 'fixedcase)
              )))
      (error (message "Error 17b! err=%s" err)))

    (checkpoint "checkpoint:18")

    (condition-case err
        (when (or (eq major-mode 'c++-mode)
                  (eq major-mode 'lisp++-mode))
          (goto-char (point-min))
          (while (re-search-forward (concat "\\<friend class \\([a-z]+::\\)?" str-variable1234-no-space ";") nil t)
            ;;friend class dmp::int;
            (setq str (if (and (match-beginning 1) (match-end 1))
                          (buffer-substring-no-properties (match-beginning 1) (match-end 1))
                        ""))
            (if (string= str "")
                (progn
                  (setq str1 "")
                  (setq str2 ""))
              (assert (> (length str) 2))
              (assert (and (>= (aref str 0) ?a) (<= (aref str 0) ?z)))
              (assert (= (aref str (- (length str) 2)) ?:))
              (assert (= (aref str (- (length str) 1)) ?:))
              (setq str1 (substring str 0 -2))
              (setq str2 (substring str -2)))
            (message "str=%s, str1=%s, str2=%s" str str1 str2)
            (if (string= str "")
                (replace-match       "(7cxxclss){(2zz)bf{friend class}} {(2zz)color{clss}{\\2}}(7cxxsslc);" 'fixedcase)
              (replace-match (format "(7cxxclss){(2zz)bf{friend class}} {(2zz)color{red}{%s}}::{(2zz)color{clss}{\\2}}(7cxxsslc);"
                                     str1) 'fixedcase)
              )))
      (error (message "Error 18! err=%s" err)))

    (checkpoint "checkpoint:19")

    (condition-case err
        (when (or (eq major-mode 'c++-mode)
                  (eq major-mode 'lisp++-mode))
          (goto-char (point-min))
          (while (re-search-forward "\\(\\<DCODE_GENERIC\\>\\)" nil t)
            (if (not (d-latexize--inside-comment-or-string))
                (replace-match "(7cxxgrnc){(2zz)color{red}(2zz)colorbox{cyan}{\\1}}(7cxxcnrg)" 'fixedcase)
              )
            )
          )
      (error (message "Error 19! err=%s" err)))

    (checkpoint "checkpoint:20")

    (condition-case err
        (when (or (eq major-mode 'c++-mode)
                  (eq major-mode 'lisp++-mode))
          (goto-char (point-min))
          (while (re-search-forward "\\(\\<DCODE_[A-Z0-9_]*\\)" nil t)
            (if (save-excursion
                  (d-goto-char-safe (- (point) 3))
                  (not (d-latexize--inside-comment-or-string)))
                (replace-match "(7cxxredc){(2zz)color{white}(2zz)colorbox{red}{\\1}}(7cxxcder)" 'fixedcase)
              )
            )
          )
      (error (message "Error 20! err=%s" err)))

    (checkpoint "checkpoint:21")

    (condition-case err
        (when (eq major-mode 'c++-mode)
          (goto-char (point-min))
          (while (re-search-forward "\\<\\(enum_debug_code\\)[ \t]+\\([a-zA-Z0-9_]+\\)" nil t)
            (if (not (d-latexize--inside-comment-or-string))
                (replace-match "(7cxxclss){(2zz)color{clss}{\\1}}(7cxxsslc) (7cxxvari){(2zz)color{vari}{\\2}}(7cxxirav)" 'fixedcase)
              )))
      (error (message "Error 21! err=%s" err)))

    (checkpoint "checkpoint:21b")

    (condition-case err
        (when (eq major-mode 'c++-mode)
          (goto-char (point-min))
          (while (re-search-forward "\\<\\(enum\\)[ \t]+\\([a-zA-Z0-9_]+\\)" nil t)
            (if (not (d-latexize--inside-comment-or-string))
                (replace-match "(7cxxclss){(2zz)bf{enum}}(7cxxsslc) (7cxxclss){(2zz)color{clss}{\\2}}(7cxxsslc)" 'fixedcase)
              )))
      (error (message "Error 21b! err=%s" err)))

    (checkpoint "checkpoint:22")

    (condition-case err
        (when (eq major-mode 'emacs-lisp-mode)
          (goto-char (point-min))
          (while (re-search-forward (concat "\\([][ \t\r\n()]\\)"
                                            "\\(red[-a-zA-Z0-9_]*\\)") nil t)
            ;; prod-red-foo
            ;; red-foo
            (if (not (d-latexize--inside-comment-or-string))
                (replace-match "\\1(7cxxvari){(2zz)color{red}{\\2}}(7cxxirav)" 'fixedcase)
              )))
      (error (message "Error 22! err=%s" err)))

     (checkpoint "checkpoint:23")

     (condition-case err
         (when (or (eq major-mode 'c++-mode)
                   (eq major-mode 'lisp++-mode))
           (goto-char (point-min))
           (while (re-search-forward "\\(\\<[A-Z][a-zA-Z0-9_]*\\)::\\([a-z][a-zA-Z0-9_]*\\)\\([ \t]*=\\)" nil t)
             (if (and (not (d-latexize--inside-comment-or-string))
                      (not (d-latexize--inside-main)))
                 (replace-match "(7cxxvari)\\1::{(2zz)color{vari}{\\2}}(7cxxirav)\\3" 'fixedcase))))
       (error (message "Error 23! err=%s" err)))

     (checkpoint "checkpoint:23b")

     (condition-case err
         (when (or (eq major-mode 'c++-mode)
                   (eq major-mode 'lisp++-mode))
           (goto-char (point-min))
           (while (re-search-forward "\\(\\<[A-Z][a-zA-Z0-9_]*\\)::\\([a-z][a-zA-Z0-9_]*\\)\\([ \t]*(\\)" nil t)
             (if (and (not (d-latexize--inside-comment-or-string))
                      (not (d-latexize--inside-main)))
                 (replace-match "(7cxxfunc)\\1::{(2zz)bf(2zz)colorbox{func}{\\2}}(7cxxcnuf)\\3" 'fixedcase))))
       (error (message "Error 23b! err=%s" err)))

     (checkpoint "checkpoint:23c")

     (condition-case err
         (when (eq major-mode 'c++-mode)
           (goto-char (point-min))
           (while (re-search-forward "\\<operator[ \t]*\\([^ a-zA-Z0-9_\t()]+\\)[ \t]*(" nil t)
             ;;(message "line=\"%s\"" (d-current-line-as-string))
             (when (not (d-latexize--inside-comment-or-string))
               (setq str (buffer-substring-no-properties (match-beginning 1) (match-end 1)))
               ;;(message "str=\"%s\"" str)
               ;;(message "buffer-substring=\"%s\"" (buffer-substring-no-properties (match-beginning 0) (match-end 0)))
               (if (string= str "")
                   (error "Empty string in operator"))
               (replace-match "(7cxxfunc){(2zz)bf(2zz)color{black}{operator}} {(2zz)colorbox{func}{\\1}}(7cxxcnuf)(" 'fixedcase)
               )
             )
           )
       (error (message "Error 23c! err=%s" err)))

     (checkpoint "checkpoint:24")

     (condition-case err
         (when (eq major-mode 'c++-mode)
           (goto-char (point-min)) ;;            123456789
           (while (re-search-forward (concat "\\(         " ;; 1
                                             str-variable1234-no-space ;; 2345
                                             "\\)"
                                             "(\\*\\([a-z][a-zA-Z0-9_]*\\))(") nil t) ;; 6
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "\\1(7cxxclss)(*{(2zz)color{vari}{\\6}})(7cxxsslc)(" 'fixedcase))))
       (error (message "Error 24! err=%s" err)))

     (checkpoint "checkpoint:25")

     (condition-case err
         (when (or (eq major-mode 'c++-mode)
                   (eq major-mode 'lisp++-mode))
           (goto-char (point-min))
           (while (re-search-forward "\\<\\(private_[a-zA-Z0-9_]*\\|_[a-zA-Z0-9_]*\\)" nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "(7cxxprvt){(2zz)bf(2zz)colorbox{prvt}{(2zz)color{white}{\\1}}}(7cxxtvrp)" 'fixedcase)
               )))
       (error (message "Error 25! err=%s" err)))

     (checkpoint "checkpoint:26")

     (condition-case err
         (when (or (eq major-mode 'c++-mode)
                   (eq major-mode 'lisp++-mode))
           (goto-char (point-min))
           (while (re-search-forward (concat str-variable1234-no-space "\\<\\(private_[a-zA-Z0-9_]*\\|_[a-zA-Z0-9_]*\\)[ \t]*\\(;\\|=\\)") nil t)
             ;;int***&** Array_Array_String;
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "(7cxxclss){(2zz)bf(2zz)color{clss}{\\1}}(7cxxsslc)(7cxxprvt){(2zz)colorbox{prvt}{(2zz)color{white}}{\\5}}(7cxxprvt) \\6" 'fixedcase)
               )))
       (error (message "Error 26! err=%s" err)))

     (checkpoint "checkpoint:27")

     (condition-case err
         (when (or (eq major-mode 'c++-mode)
                   (eq major-mode 'lisp++-mode))
           (goto-char (point-min))
           (while (re-search-forward (concat str-variable1234-no-space
                                             "\\([ \t]*[,)]\\)") nil t) ;; GOT1!
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "(7cxxclss){(2zz)color{clss}{\\1}}(7cxxsslc)\\5" 'fixedcase))))
       (error (message "Error 27! err=%s" err)))

     (checkpoint "checkpoint:28")

     (condition-case err
         (when (or (eq major-mode 'c++-mode)
                   (eq major-mode 'lisp++-mode))
           (goto-char (point-min))
           (while (re-search-forward (concat str-variable1234-yes-space
                                             "\\([a-zA-Z_][a-zA-Z0-9_]*\\)\\([ \t]*\\)\\(;\\|=\\)") nil t) ;;GOT2!
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "(7cxxclss){(2zz)color{clss}{\\1}}(7cxxsslc)(7cxxvari){(2zz)color{vari}{\\5}}(7cxxirav)\\6\\7" 'fixedcase))))
       (error (message "Error 28! err=%s" err)))

     (checkpoint "checkpoint:29")

     (condition-case err
         (when (or (eq major-mode 'c++-mode)
                   (eq major-mode 'lisp++-mode))
           (goto-char (point-min))
           (while (re-search-forward (concat str-variable1234-yes-space ;; GOT3!
                                             "\\([a-zA-Z_][a-zA-Z0-9_]*\\)\\([ \t]*[,)]\\)") nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "(7cxxclss){(2zz)color{clss}{\\1}}(7cxxsslc)(7cxxvari){(2zz)color{vari}{\\5}}(7cxxirav)\\6" 'fixedcase)
               )))
       (error (message "Error 29! err=%s" err)))

     (checkpoint "checkpoint:30")

     (condition-case err
         (when (or (eq major-mode 'c++-mode)
                   (eq major-mode 'lisp++-mode))
           (goto-char (point-min))
           (while (re-search-forward (concat str-variable1234-no-space
                                             "\\([ \t]*[),]\\)") nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "(7cxxclss){(2zz)color{clss}{\\1}}(7cxxsslc)\\5" 'fixedcase))))
       (error (message "Error 30! err=%s" err)))

     (checkpoint "checkpoint:31")

     (condition-case err
         (when (or (eq major-mode 'c++-mode)
                   (eq major-mode 'lisp++-mode))
           (goto-char (point-min))
           (while (re-search-forward (concat
                                      str-variable1234-yes-space
                                      "\\(ctor[a-zA-Z0-9_]*\\)(") nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "(7cxxclss){(2zz)color{clss}{\\1}}(7cxxsslc)(7cxxnumb){(2zz)bf(2zz)color{numb}{\\5}}(7cxxbmun)(" 'fixedcase)
               )))
       (error (message "Error 31! err=%s" err)))

     (checkpoint "checkpoint:32")

     (condition-case err
         (when (or (eq major-mode 'c++-mode)
                   (eq major-mode 'lisp++-mode))
           (goto-char (point-min))
           (while (re-search-forward "::\\(ctor[a-zA-Z0-9_]*\\)(" nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "(7cxxvari)::{(2zz)bf(2zz)color{numb}{\\1}}(7cxxirav)(" 'fixedcase)
               )))
       (error (message "Error 32! err=%s" err)))

     (checkpoint "checkpoint:33")

     (condition-case err
         (when (eq major-mode 'c++-mode)
           (goto-char (point-min))
           (while (re-search-forward "\\<\\(\\(using \\)?namespace\\) \\([a-zA-Z0-9_]+\\)" nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "{(2zz)bf{\\1}} {(2zz)color{red}{\\3}}" 'fixedcase))))
       (error (message "Error 33! err=%s" err)))

     (checkpoint "checkpoint:34")

     (condition-case err
         (when (or (eq major-mode 'c++-mode)
                   (eq major-mode 'java-mode)
                   (eq major-mode 'jtw-mode))
           (goto-char (point-min))
           (while (re-search-forward "\\<\\(class\\|interface\\|struct\\) \\([A-Za-z_][A-Za-z0-9_]*\\)" nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "(7cxxclss){(2zz)bf{\\1}} {(2zz)color{clss}{\\2}}(7cxxsslc)" 'fixedcase)
               )))
       (error (message "Error 34! err=%s" err)))

     (checkpoint "checkpoint:35")

     (when (eq major-mode 'lisp++-mode)
       (checkpoint "checkpoint:36")
       (condition-case err
           (let (result str)
             (goto-char (point-min))
             (while (re-search-forward "(\\(cmethod\\|c-static-method\\|cfunction\\|cfriend\\)" nil t)
               (when (and (not (d-latexize--inside-comment))
                          (not (d-latexize--inside-string)))
                 (replace-match "((7cxxgrnc){(2zz)color{green-keyw}{\\1}}(7cxxcnrg)" 'fixedcase)
                 (d-goto-char-safe (match-beginning 0))
                 (message "cmethod\\|c-static-method\\|cfunction\\|cfriend"))
               (when (and (re-search-forward "(cret \\([^()]*\\))" (point-at-eol) t)
                          (not (d-latexize--inside-comment))
                          (not (d-latexize--inside-string)))
                 (d-goto-char-safe (match-beginning 0))
                 (replace-match "(cret (7cxxclss){(2zz)color{clss}{\\1}}(7cxxsslc))" 'fixedcase)
                 (message "cret"))
               (when (and (re-search-forward "(cname \\([^()]*\\))" (point-at-eol) t)
                          (not (d-latexize--inside-comment))
                          (not (d-latexize--inside-string)))
                 (d-goto-char-safe (match-beginning 0))
                 (setq str (buffer-substring-no-properties (match-beginning 1) (match-end 1)))
                 (message "str=%s" str)
                 (cond
                  ((save-match-data
                     (string-match "\\<operator[ \t]*<<" str))
                   (replace-match "(cname (7cxxfunc){(2zz)bf{operator}(2zz)colorbox{func}{<<}}(7cxxcnuf))" 'fixedcase)
                   ;;(debug "Calisthenics")
                   )
                  ((save-match-data
                     (string-match "\\<operator[ \t]*>>" str))
                   (replace-match "(cname (7cxxfunc){(2zz)bf{operator}(2zz)colorbox{func}{>>}}(7cxxcnuf))" 'fixedcase)
                   ;;(debug "Both sides now")
                   )
                  (t
                   (save-match-data
                     (if (string-match "\\<operator[ \t]*\\([^ ()]*\\)" str)
                         (progn
                           (setq str (substring str (match-beginning 1) (match-end 1)))
                           (setq result t))
                       (setq result nil)
                       (assert (not (string-match "\\<operator\\>" str)))
                       ))
                   (if result
                       (replace-match (format "(cname (7cxxfunc){{(2zz)bf{operator}}{(2zz)bf(2zz)colorbox{func}{%s}}}(7cxxcnuf))" str) 'fixedcase)
                     (replace-match   (format "(cname (7cxxfunc){(2zz)bf(2zz)colorbox{func}{%s}}(7cxxcnuf))" str) 'fixedcase)
                     ;;(message "replace match with %s" (format "(cname (7cxxfunc){(2zz)bf(2zz)colorbox{func}{%s}}(7cxxcnuf))" str))
                     )) ;; END T!
                  ) ;; END COND!
                 )))
         (error (message "Error 36! err=%s" err)))
       (checkpoint "checkpoint:37")
       (condition-case err
           (progn
             (message "checkpoint:37b")
             (goto-char (point-min))
             (while (re-search-forward "(\\(c-constructor-method\\|c-destructor-method\\)" nil t)
               (when (not (d-latexize--inside-comment-or-string))
                 (replace-match "((7cxxglbl){(2zz)color{green-keyw}{\\1}}(7cxxlblg)" 'fixedcase)
                 (d-goto-char-safe (match-beginning 0))
                 (when (and (re-search-forward "(cname \\([^()]*\\))" (point-at-eol) t)
                            (not (d-latexize--inside-comment-or-string)))
                   (replace-match "(cname (7cxxclss){(2zz)color{clss}{\\1}}(7cxxsslc))" 'fixedcase)
                   (d-goto-char-safe (match-beginning 0))
                   ))))
         (error "Error 37b! err=%s" err))
       (checkpoint "checkpoint:38")
       (condition-case err
           (progn
             (goto-char (point-min))
             (while (re-search-forward "(\\(cglobal\\|cproperty\\|c-static-property\\)" nil t)
               (when (not (d-latexize--inside-comment-or-string))
                 (replace-match "((7cxxgrnc){(2zz)color{green-keyw}{\\1}}(7cxxcnrg)" 'fixedcase)
                 (beginning-of-line))
               (when (and (re-search-forward "(ctype \\([^()]*\\))" (point-at-eol) t)
                          (not (d-latexize--inside-comment-or-string)))
                 (replace-match "(ctype (7cxxclss){(2zz)color{clss}{\\1}}(7cxxsslc))" 'fixedcase)
                 (beginning-of-line))
               (when (and (re-search-forward "(cname \\([^()]*\\))" (point-at-eol) t)
                          (not (d-latexize--inside-comment-or-string)))
                 (setq str (buffer-substring-no-properties (match-beginning 1) (match-end 1))) ;; (cname _abc_def)
                 (if (save-match-data
                       (string-match "^_[a-zA-Z0-9_]*$" str))
                     ;;(setq str "_abc")
                     (progn
                       (replace-match  "(cname (7cxxprvt){(2zz)bf(2zz)colorbox{prvt}{(2zz)color{white}{\\1}}}(7cxxtvrp))" 'fixedcase)
                       ;;(error "That man is full of cheer")
                       )
                   (replace-match "(cname (7cxxvari){(2zz)color{vari}{\\1}}(7cxxirav))" 'fixedcase)
                   ))
               (beginning-of-line)
               ;;"(cinit =[ \t]*\\([-+]?0[xX][a-fA-F0-9]+\\|[-+]?[0-9]+\\(\\.[0-9]+\\)+\\([eE][-+]?[0-9]+\\)+\\))"
               ;;"(cinit =[ \t]*\\([-+]?0[xX][a-fA-F0-9]+\\|[-+]?[0-9]+\\([eE][-+]?[0-9]+\\)+\\))"
               (setq str (concat
                          "\\([-+]?0[xX][a-fA-F0-9]+"
                          "\\|[-+]?[0-9]+"
                          "\\|[-+]?[0-9]+\\.[0-9]+"
                          "\\|[-+]?[0-9]+[Ee][-+]?[0-9]+"
                          "\\|[-+]?[0-9]+\\.[0-9]+[Ee][-+]?[0-9]+"
                          "\\)"
                          ))
               (setq str (concat
                          "\\(0[xX][a-fA-F0-9]+"
                          "\\|[0-9]+"
                          "\\|[0-9]+\\.[0-9]+"
                          "\\|[0-9]+e[0-9]+"
                          "\\|[0-9]+\\.[0-9]+e[0-9]+"
                          "\\)"
                          ))
               (setq str (concat
                          "\\(0[xX][a-fA-F0-9]+"
                          "\\|[0-9]+\\(\\.[0-9]+\\)?\\(e[0-9]+\\)?"
                          "\\)"
                          ))
               ;;(when (and (re-search-forward (concat "(cinit =[ \t]*" str ")") (point-at-eol) t)
               ;;           (not (d-latexize--inside-comment-or-string)))
               ;;  ;;(buffer-substring-no-properties (match-beginning 1) (match-end 1))
               ;;  (replace-match "(cinit = (7cxxnumb){(2zz)color{numb}{\\1}}(7cxxbmun))" 'fixedcase)
               ))          ;; (cinit = 123e789)
         (error (message "Error 38! err=%s" err)))
       (checkpoint "checkpoint:39")
       (condition-case err
           (progn
             (goto-char (point-min))
             (while (re-search-forward "(cinit =[ \t]*\\([-+]?[0-9]+\\.[0-9]+[eE][0-9]+\\))" nil t)
               (if (not (d-latexize--inside-comment-or-string))
                   (replace-match "(cinit = (7cxxnumb){(2zz)color{numb}{\\1}}(7cxxbmun))" 'fixedcase)
               ))
             (goto-char (point-min))
             (while (re-search-forward "(cinit =[ \t]*\\([-+]?[0-9]+\\.[0-9]+\\))" nil t)
               (if (not (d-latexize--inside-comment-or-string))
                   (replace-match "(cinit = (7cxxnumb){(2zz)color{numb}{\\1}}(7cxxbmun))" 'fixedcase)
               ))
             (goto-char (point-min))
             (while (re-search-forward "(cinit =[ \t]*\\([-+]?[0-9]+[eE][0-9]+\\))" nil t)
               (if (not (d-latexize--inside-comment-or-string))
                   (replace-match "(cinit = (7cxxnumb){(2zz)color{numb}{\\1}}(7cxxbmun))" 'fixedcase)
               ))
             (goto-char (point-min))
             (while (re-search-forward "(cinit =[ \t]*\\([-+]?[0-9]+\\))" nil t)
               (if (not (d-latexize--inside-comment-or-string))
                   (replace-match "(cinit = (7cxxnumb){(2zz)color{numb}{\\1}}(7cxxbmun))" 'fixedcase)
               ))
             )
         (error (message "Error 39! err=%s" err)))
       )

     (checkpoint "checkpoint:39b")

     (condition-case err
         (when (or (eq major-mode 'c++-mode)
                   (eq major-mode 'lisp++-mode))
           (checkpoint "checkpoint:39c")
           (goto-char (point-min))
           (while (re-search-forward (concat str-variable1234-yes-space
                                             "\\([a-z][a-zA-Z0-9_]*\\)[ \t]*(") nil t)
             (setq str (buffer-substring-no-properties (match-beginning 5) (match-end 5)))
             (message "str=%s" str)
             (when (not (d-latexize--inside-comment-or-string))
               (if (save-match-data
                     (and (not (string-match "^a[0-9]*$" str))
                          (not (string-match "^d[0-9]*$" str))
                          (not (string-match "^r[0-9]*$" str))
                          (not (string-match "^w[0-9]*$" str))
                          (not (string-match "^p[0-9]*$" str))
                          (not (string-match "^f[0-9]*$" str))
                          (not (string-match "^data[0-9]*$" str))
                          (not (string-match "^self[0-9]*$" str))))
                   (progn
                     (replace-match "(7cxxclss){(2zz)color{clss}{\\1}(7cxxsslc)} {(7cxxfunc)(2zz)bf(2zz)colorbox{func}{\\5}(7cxxcnuf)}(" 'fixedcase)
                     (checkpoint "checkpoint:39d"))
                 ;;(debug "not branch")
                 (replace-match "(7cxxclss){(2zz)color{clss}{\\1}(7cxxsslc)} (7cxxvari){(2zz)color{vari}{\\5}}(7cxxirav)(" 'fixedcase)
                 ))
             (checkpoint "checkpoint:39f")
             ))
       (error (message "Error 39b! err=%s" err)))

     (checkpoint "checkpoint:39c")

     (condition-case err
         (when (or (eq major-mode 'c++-mode)
                   (eq major-mode 'lisp++-mode))
           (goto-char (point-min))
           (while (re-search-forward (concat str-variable1234-yes-space
                                             "\\(~?[A-Z][a-zA-Z0-9_]*\\)[ \t]*(") nil t)
               ;;(when (not (d-looking-at-7cxx (match-end 1)))
             (setq str (buffer-substring-no-properties (match-beginning 5) (match-end 5)))
             (if (not (d-latexize--inside-comment-or-string))
                 (if (save-match-data
                       (and (not (string-match "^a[0-9]*$" str))
                            (not (string-match "^d[0-9]*$" str))
                            (not (string-match "^r[0-9]*$" str))
                            (not (string-match "^w[0-9]*$" str))
                            (not (string-match "^p[0-9]*$" str))
                            (not (string-match "^f[0-9]*$" str))
                            (not (string-match "^data[0-9]*$" str))
                            (not (string-match "^self[0-9]*$" str))))
                     (replace-match "(7cxxclss){(2zz)color{clss}{\\1 \\5}}(7cxxsslc)(" 'fixedcase)
                   (replace-match "(7cxxclss){(2zz)color{clss}{\\1 CLSS2!\\5}}(7cxxsslc)(" 'fixedcase)
               ))))
       (error (message "Error 39c! err=%s" err)))

     (checkpoint "checkpoint:40")

     (condition-case err
         (when (or (eq major-mode 'c++-mode)
                   (eq major-mode 'lisp++-mode))
           (goto-char (point-min))
           (while (re-search-forward (concat str-variable1234-yes-space
                                             "\\([A-Z]+[a-z][a-zA-Z0-9_]*\\)::") nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "(7cxxclss){(2zz)color{clss}{\\1\\5}(7cxxsslc)}::" 'fixedcase)
               )))
       (error (message "Error 40! err=%s" err)))

     (checkpoint "checkpoint:40b")

     (condition-case err
         (when (or (eq major-mode 'c++-mode)
                   (eq major-mode 'lisp++-mode))
           (goto-char (point-min))
           (while (re-search-forward (concat str-variable1234-yes-space
                                             "\\([A-Z]+[a-z][a-zA-Z0-9_]*\\)(") nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "(7cxxclss){(2zz)color{clss}{\\1\\5}(7cxxsslc)}(" 'fixedcase)
               )))
       (error (message "Error 40b! err=%s" err)))

     (checkpoint "checkpoint:41")

     (condition-case err
         (when (eq major-mode 'c++-mode)
           (goto-char (point-min))
           (while (re-search-forward (concat str-variable1234-yes-space
                                             "\\([a-zA-Z_][a-zA-Z0-9_]*\\)[ \t]*=[ \t]*") nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "(7cxxclss){(2zz)color{clss}{\\1}}(7cxxsslc)(7cxxvari){(2zz)color{vari}{VARI3!\\5}}(7cxxirav) = " 'fixedcase)
               )))
       (error (message "Error 41! err=%s" err)))

     (checkpoint "checkpoint:42")

     (condition-case err
         (when (eq major-mode 'c++-mode)
           (goto-char (point-min))
           (while (re-search-forward (concat str-variable1234-yes-space
                                             "\\([a-zA-Z_][a-zA-Z0-9_]*\\)::\\([a-zA-Z_][a-zA-Z0-9_]*\\)[ \t]*=[ \t]*") nil t)
             (if (and (not (d-latexize--inside-comment))
                      (not (d-latexize--inside-string)))
                 (replace-match "(7cxxclss){(2zz)color{clss}{\\1\\5::}}(7cxxsslc)(7cxxvari){(2zz)color{vari}{\\6}}(7cxxirav) = " 'fixedcase)
               )))
       (error (message "Error 42! err=%s" err)))

     (checkpoint "checkpoint:43")

     (condition-case err
         (when (eq major-mode 'c++-mode)
           (goto-char (point-min))
           (while (re-search-forward (concat str-variable1234-yes-space
                                             "\\([a-zA-Z_][a-zA-Z0-9_]*\\)::\\(~?[a-zA-Z_][a-zA-Z0-9_]*\\)(") nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "(7cxxclss){(2zz)color{clss}{\\1\\5::}}(7cxxsslc)(7cxxfunc){(2zz)colorbox{func}{\\6}}(7cxxcnuf)(" 'fixedcase)
               ))
           )
       (error (message "Error 44! err=%s" err)))

     (checkpoint "checkpoint:44")

     (condition-case err
         (when (or (eq major-mode 'c++-mode)
                   (eq major-mode 'lisp++-mode))
           (goto-char (point-min))
           (while (re-search-forward (concat str-variable1234-yes-space
                                             "\\([a-zA-Z_][a-zA-Z0-9_]*\\)[ \t]*=[ \t]*") nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "(7cxxclss){(2zz)color{clss}{\\1}}(7cxxsslc)(7cxxvari){(2zz)color{vari}{\\5}}(7cxxirav) = " 'fixedcase)))
           )
       (error (message "Error 44! err=%s" err)))

     (checkpoint "checkpoint:45")

     (condition-case err
         (when (eq major-mode 'c++-mode)
           (goto-char (point-min))
           (while (re-search-forward (concat str-variable1234-no-space "(") nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "(7cxxclss){(2zz)color{clss}{\\1}}(7cxxsslc)(" 'fixedcase)))
           )
       (error (message "Error 45! err=%s" err)))

     (checkpoint "checkpoint:46")

     (condition-case err
         (when (or (eq major-mode 'c++-mode)
                   (eq major-mode 'lisp++-mode))
           (goto-char (point-min))
           (while (re-search-forward "\\(using namespace\\) \\([a-z]+\\)" nil t)
             (replace-match "{(2zz)bf{\\1}} (7cxxredc){(2zz)color{red}{\\2}}(7cxxcder)" 'fixedcase)))
       (error (message "Error 46! err=%s" err)))

     (checkpoint "checkpoint:47")

     (condition-case err
         (when (eq major-mode 'c++-mode)
           (goto-char (point-min))
           (while (re-search-forward "\\<\\(\\(const[ \t]+\\)?m?ptr[&*]*\\) \\([a-z][a-zA-Z0-9_]*\\)\\([),]\\)" nil t)
             (if (not (d-latexize--inside-comment-or-string))
             (replace-match "(7cxxclss){(2zz)color{clss}{\\1}}(7cxxsslc) (7cxxvari){(2zz)color{vari}{\\3}}(7cxxirav)\\4" 'fixedcase)
             )))
       (error (message "Error 47b! err=%s" err)))

     (checkpoint "checkpoint:47b")

     (condition-case err
         (when (eq major-mode 'c++-mode)
           (goto-char (point-min))
           (while (re-search-forward "\\<\\(\\(const[ \t]+\\)?m?ptr[&*]*\\)" nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "(7cxxclss){(2zz)color{clss}{\\1}}(7cxxsslc)" 'fixedcase)
               )))
       (error (message "Error 47b! err=%s" err)))

     (checkpoint "checkpoint:47c")

     (condition-case err
         (when (or (eq major-mode 'c++-mode)
                   (eq major-mode 'lisp++-mode))
           (goto-char (point-min))
           (while (re-search-forward "\\<\\(const_cast\\|reinterpret_cast\\|static_cast\\)<\\(.*\\)>" nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "\\1<{(2zz)color{clss}{\\2}}>" 'fixedcase)
               )))
       (error (message "Error 47c! err=%s" err)))

     (checkpoint "checkpoint:49")

     (condition-case err
         (when (or (eq major-mode 'c++-mode)
                   (eq major-mode 'lisp++-mode))
           (goto-char (point-min))
           (while (progn
                    (d-goto-char-safe (- (point) 1))
                    (re-search-forward (concat
                                        "\\([^a-zA-Z0-9_]\\)\\(new\\|delete\\|virtual\\|"
                                        "struct\\|const_cast\\|return\\|namespace\\|"
                                        "switch\\|case\\|break\\|const\\|"
                                        "reinterpret_cast\\|extern\\|static\\|"
                                        "if\\|else\\|for\\|while\\|do\\|typedef\\|goto\\|"
                                        "class\\|this\\|template\\|friend\\)\\([^a-zA-Z0-9_]\\)") nil t))
             (if (save-excursion
                   (d-goto-char-safe (- (point) 1))
                   (and (not (d-latexize--inside-comment))
                        (not (d-latexize--inside-string))
                        (not (d-latexize--inside-grnc))
                        (not (d-latexize--inside-vari))
                        (not (d-latexize--inside-hash))
                        ))
                 (replace-match "\\1{(2zz)color{black}(2zz)bf{\\2}}\\3" 'fixedcase)
               )))
       (error (message "Error 49! err=%s" err)))

     (checkpoint "checkpoint:50")

     (condition-case err
         (when (or (eq major-mode 'c++-mode)
                   (eq major-mode 'lisp++-mode)
                   (eq major-mode 'emacs-lisp-mode))
           (goto-char (point-min))
           (while (re-search-forward (concat "\\<\\(SHOULD_NEVER_HAPPEN\\|ASSERT_INFO\\|"
                                             "EXIT_SUCCESS\\|EXIT_FAILURE\\|ERROR\\|should_never_happen\\|"
                                             "assert\\|ASSERT\\|true\\|false\\|null\\)\\>") nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "{(2zz)color{red}{\\&}}" 'fixedcase))))
       (error (message "Error 50! err=%s" err)))

     (checkpoint "checkpoint:51")

     (condition-case err
        (when (or (eq major-mode 'c++-mode)
                  (eq major-mode 'lisp++-mode))
          (goto-char (point-min))
          (while (re-search-forward "\\(File_Reader\\|File_Writer\\|Writer\\|Reader\\)\\([&*]*\\)[ \t]+\\([a-z][a-zA-Z0-9_]*\\)" nil t)
            (if (not (d-latexize--inside-comment-or-string))
                (replace-match "(7cxxclss){(2zz)color{clss}{\\1\\2}}(7cxxsslc) (7cxxvari){(2zz)color{vari}{\\3}}(7cxxirav)" 'fixedcase)
              )))
      (error (message "Error 51! err=%s" err)))

     (checkpoint "checkpoint:54")

     (condition-case err
         (when (eq major-mode 'c++-mode)
           (goto-char (point-min))
           (while (re-search-forward (concat str-variable1234-yes-space
                                             "\\([a-zA-Z_][a-zA-Z0-9_]*\\)")
                                     nil t)
             (when (save-excursion
                     (d-goto-char-safe (- (point) 2))
                     (not (d-latexize--inside-comment-or-string)))
               (setq operator (buffer-substring-no-properties (match-beginning 5) (match-end 5)))
               (if (not (string= operator "operator"))
                   (replace-match "(7cxxclss){(2zz)color{clss}{\\1}}(7cxxsslc)(7cxxvari){(2zz)color{vari}{\\5}}(7cxxirav)" 'fixedcase)
                 ))))
       (error (message "Error 54! err=%s" err)))

     (checkpoint "checkpoint:55")

     (setq class-re1 "\\([A-Z][0-9]?\\|[A-Z]+[a-z][a-zA-Z0-9_<,]*[ >]*\\)")

     (condition-case err
         (when (or (eq major-mode 'c++-mode)
                   (eq major-mode 'lisp++-mode))
           (goto-char (point-min))
           (while (re-search-forward (concat "\\<" class-re1 "\\(::~?\\)" class-re1 "(") nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "(7cxxclss){(2zz)color{clss}{\\1\\2\\3}}(7cxxsslc)(" 'fixedcase)
               )))
       (error (message "Error 55! err=%s" err)))

     (checkpoint "checkpoint:56")

     (condition-case err
         (when (or (eq major-mode 'c++-mode)
                   (eq major-mode 'lisp++-mode))
           (goto-char (point-min))
           (while (re-search-forward (concat "\\([^a-zA-Z0-9_]\\)\\(~?\\)" class-re1 "(") nil t)
             ;; A(f 1 2 3)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "\\1(7cxxclss){(2zz)color{clss}{\\2\\3}}(7cxxsslc)(" 'fixedcase)
               )))
       (error (message "Error 56! err=%s" err)))

     (checkpoint "checkpoint:56b")

     (condition-case err
         (when (or (eq major-mode 'c++-mode)
                   (eq major-mode 'lisp++-mode))
           (goto-char (point-min))
           (while (re-search-forward (concat "\\([^a-zA-Z0-9_]\\)\\(~?\\)" class-re1 "\\([&*]*\\)[ \t]+\\([a-z][a-zA-Z0-9_]*\\)(") nil t)
             ;; A&** a1(f 1 2 3);
             (setq str (buffer-substring-no-properties (match-beginning 4) (match-end 4)))
             (when (not (d-latexize--inside-comment-or-string))
               (if (string-match "a[0-9]+" str)
                   (replace-match "\\1(7cxxclss){(2zz)color{clss}{\\2\\3\\4}}(7cxxsslc) (7cxxfunc){(2zz)colorbox{func}{\\5}}(7cxxcnuf)(" 'fixedcase)
                 (replace-match "\\1(7cxxclss){(2zz)color{clss}{\\2\\3\\4}}(7cxxsslc) (7cxxvari){(2zz)color{vari}{\\5}}(7cxxirav)(" 'fixedcase)
               ))))
       (error (message "Error 56b! err=%s" err)))

     (checkpoint "checkpoint:57")

     (condition-case err
         (when (or (eq major-mode 'c++-mode)
                   (eq major-mode 'lisp++-mode))
           (goto-char (point-min))
           (while (progn
                    (d-goto-char-safe (- (point) 1))
                    (re-search-forward (concat "\\<" class-re1 "::") nil t))
             (d-goto-char-safe (- (point) 1))
             ;;(message "*** (point)=%s" (point))
             (if (and (not (d-latexize--inside-comment))
                      (not (d-latexize--inside-string)))
                 (replace-match "(7cxxclss){(2zz)color{clss}{\\1}}::(7cxxsslc)" 'fixedcase)
               )))
       (error (message "Error 57! err=%s" err)))

     (checkpoint "checkpoint:58")

     (condition-case err
         (when (eq major-mode 'c++-mode)
           (goto-char (point-min))
           (while (re-search-forward "\\([^a-zA-Z0-9_{}]\\)\\(_[a-z][a-zA-Z0-9_]*\\)" nil t)
             (if (and (not (d-latexize--inside-comment))
                      (not (d-latexize--inside-string)))
                 (replace-match "\\1(7cxxprvt){(2zz)bf(2zz)colorbox{prvt}{(2zz)color{white}{\\2}}}(7cxxtvrp)" 'fixedcase)
               )
             )
           )
       (error (message "Error 58! err=%s" err)))

     (checkpoint "checkpoint:59")

     (condition-case err
         (when (eq major-mode 'lisp++-mode)
           (while (re-search-forward "(carg\\([^(){}]+\\)[ \t]+\\([^(){}]+\\))" nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "(carg(7cxxclss){(2zz)color{clss}{\\1}}(7cxxsslc) (7cxxvari){(2zz)color{vari}{\\2}}(7cxxirav))" 'fixedcase)
               )))
       (error (message "Error 59! err=%s" err)))

     (condition-case err
         (when (eq major-mode 'lisp++-mode)
           (while (re-search-forward "(carg\\([^(){}]+\\))" nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "(carg(7cxxclss){(2zz)color{clss}{\\1}}(7cxxsslc))" 'fixedcase)
               )))
       (error (message "Error 59b! err=%s" err)))

     (checkpoint "checkpoint:60")

     (condition-case err
         (when (eq major-mode 'c++-mode)
           (goto-char (point-min))
           (while (re-search-forward "\\<destroy_\\([a-z][a-zA-Z0-9_]*\\)" nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "(7cxxvari){(2zz)color{numb}{\\&}}(7cxxirav)" 'fixedcase)
               )))
       (error (message "Error 60! err=%s" err)))

     (checkpoint "checkpoint:61")

     (condition-case err
         (when (eq major-mode 'c++-mode)
           (goto-char (point-min))
           (while (re-search-forward "::\\([a-z][a-zA-Z0-9_]*\\)" nil t)
             (setq str (buffer-substring-no-properties (match-beginning 1) (match-end 1)))
             (if (and (not (d-latexize--inside-comment-or-string))
                      (or  (string-match "draw_rle_sprite" str)
                           (string-match "draw_sprite" str)
                           (string-match "putpixel" str)
                           (string-match "getpixel" str)
                           (string-match "create_rle_sprite" str)))
                 (replace-match "::{(2zz)color{brown}{\\1}}" 'fixedcase)
               )))
       (error (message "Error 61! err=%s" err)))

     (checkpoint "checkpoint:62")

     (condition-case err
         (when (eq major-mode 'c++-mode)
           (goto-char (point-min))
           (while (re-search-forward "\\<allegro_[a-z][a-zA-Z0-9_]*" nil t)
             (replace-match "::{(2zz)color{brown}{\\&}}" 'fixedcase)
             ))
       (error (message "Error 62! err=%s" err)))

     (checkpoint "checkpoint:63")

     (condition-case err
         (when (eq major-mode 'c++-mode)
           (goto-char (point-min))
           (while (re-search-forward "\\<delete_current(" nil t)
             (when (not (d-latexize--inside-comment-or-string))
               (replace-match "{(2zz)color{numb}{delete_current}}(" 'fixedcase)
               )))
       (error (message "Error 63! err=%s" err)))

     (checkpoint "checkpoint:64")

     (condition-case err
         (when (eq major-mode 'lisp++-mode)
           (goto-char (point-min))
           (while (re-search-forward "(cclass \\([a-zA-Z0-9_]+\\)" nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "(cclass (7cxxclss){(2zz)color{clss}{\\1}}(7cxxsslc)" 'fixedcase)
             )))
       (error (message "Error 64! err=%s" err)))

     (checkpoint "checkpoint:65")

     (condition-case err
         (when (eq major-mode 'emacs-lisp-mode)
           (goto-char (point-min))
           (while (re-search-forward "(defun \\([-a-zA-Z0-9_+*<>:!]*\\)" nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "({(2zz)bf{defun }}(7cxxfunc){(2zz)bf(2zz)colorbox{func}{\\1}}(7cxxcnuf)" 'fixedcase)
               ))
           (checkpoint "checkpoint:66")
           (goto-char (point-min))
           (while (re-search-forward "(defmacro \\([-a-zA-Z0-9_+*<>:!]*\\)" nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "({(2zz)bf{}defmacro }(7cxxfunc){(2zz)bf(2zz)colorbox{func}{\\1}}(7cxxcnuf)" 'fixedcase)
               ))
           )
       (error (message "Error 66! err=%s" err)))

     (checkpoint "checkpoint:67")

     (condition-case err
         (when (eq major-mode 'emacs-lisp-mode)
           (goto-char (point-min))
           (while (re-search-forward "\\<\\(jtw\\|ptr\\|warn\\|d\\)\\>" nil t)
             (save-excursion
               ;;(d-goto-char-safe (- (point) 3))
               (when (not (d-latexize--inside-comment-or-string))
                 (replace-match "{(2zz)bf(2zz)color{dark-blue}{\\&}}" 'fixedcase)
                 ))))
       (error (message "Error 67! err=%s" err)))

     (checkpoint "checkpoint:68")

     (condition-case err ;; HOLE!
         (when (eq major-mode 'emacs-lisp-mode)
           (goto-char (point-min))
           (while (re-search-forward "\\<\\(jtw\\|ptr\\|warn\\|d\\)-[-a-zA-Z0-9_+<>:]*" nil t)
             (save-excursion
               (d-goto-char-safe (- (point) 3))
               (when (not (d-latexize--inside-comment-or-string))
                 (replace-match "{(2zz)bf(2zz)color{dark-blue}{\\&}}" 'fixedcase)
                 ))))
       (error (message "Error 68! err=%s!" err)))

     (checkpoint "checkpoint:69")

     (condition-case err ;; IN ONE!
         (when (eq major-mode 'emacs-lisp-mode)
           (goto-char (point-min))
           (while (re-search-forward "(\\(safe-require\\|provide\\|require\\)[ \t]+\\('[a-zA-Z0-9_+*<>:!]*\\))" nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "((7cxxredc){(2zz)bf{\\1}} {(2zz)color{red}{\\2}}(7cxxcder))" 'fixedcase)
               )))
       (error (message "Error 69! err=%s" err)))

     (checkpoint "checkpoint:70")

     (condition-case err
         (when (eq major-mode 'emacs-lisp-mode)
           (goto-char (point-min))
           (while (re-search-forward "\\<\\(read-str\\)\\>" nil t)
             (save-excursion
               (d-goto-char-safe (- (point) 3))
               (when (not (d-latexize--inside-comment-or-string))
                 (replace-match "(7cxxclss){(2zz)bf(2zz)color{dark-blue}{\\&}}(7cxxsslc)" 'fixedcase)
                 ))))
       (error (message "Error 70! err=%s" err)))

     (checkpoint "checkpoint:71")

     (condition-case err
         (when (eq major-mode 'c++-mode)
           (goto-char (point-min))
           (while (re-search-forward "\\(public\\|private\\|protected\\) \\([a-zA-Z_][a-zA-Z0-9_]*\\)" nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "\\1 {(2zz)color{clss}{\\2}}" 'fixedcase)
               )))
       (error (message "Error 71! err=%s" err)))

     (checkpoint "checkpoint:72")

     (condition-case err
         (when (eq major-mode 'c++-mode)
           (goto-char (point-min))
           (while (re-search-forward "[ \t\r\n]*\\(public\\|private\\|protected\\)\\>" nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "{(2zz)color{black}(2zz)bf{\\&}}")
               )))
       (error (message "Error 72! err=%s" err)))

     (checkpoint "checkpoint:73")

     (condition-case err
         (when (eq major-mode 'c++-mode)
           (goto-char (point-min))
           (while (re-search-forward "\\([^a-zA-Z0-9_{}]\\)\\(PRINT\\)\\((.*)\\)" nil t)
             (if (not (save-excursion
                        (forward-char -1)
                        (d-latexize--inside-comment-or-string)))
                 (replace-match "\\1{(2zz)color{glbl}{\\2}}\\3" 'fixedcase)
               )))
       (error (message "Error 73! err=%s" err)))

     (checkpoint "checkpoint:74")

     (condition-case err
         (when (eq major-mode 'emacs-lisp-mode)
           (goto-char (point-min))
           (while (re-search-forward "\\*[a-zA-Z_][-a-zA-Z0-9_+]*\\*" nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "(7cxxglbl){(2zz)color{glbl}{\\&}}(7cxxlblg)" 'fixedcase)
               )))
       (error (message "Error 74! err=%s" err)))

     (checkpoint "checkpoint:75")

     (condition-case err
         (when (eq major-mode 'emacs-lisp-mode)
           (goto-char (point-min))
           (while (re-search-forward "\\<debug\\>" nil t)
             (if (not (d-latexize--inside-comment-or-string))
                 (replace-match "{(2zz)color{red}{debug}}" 'fixedcase)
               )))
       (error (message "Error 75! err=%s" err)))

     (checkpoint "checkpoint:76")

     (checkpoint "checkpoint:77")

    (condition-case err
        (when (eq major-mode 'emacs-lisp-mode)
          (goto-char (point-min))
          (while (progn
                   (d-goto-char-safe (- (point) 2))
                   (re-search-forward "\\(^\\|[^-a-zA-Z0-9_]\\)\\(\\(global\\|GLOBAL\\)[a-zA-Z0-9_+-]*\\)\\([^a-zA-Z0-9_-]\\)"
                                      nil t))
            (if (not (save-excursion
                       (d-goto-char-safe (- (point) 4))
                       (d-latexize--inside-comment-or-string)))
                (replace-match "\\1{(2zz)color{glbl}{\\2}}\\4" 'fixedcase)
              )))
      (error (message "Error 77! err=%s" err)))

    (checkpoint "checkpoint:78")

    (condition-case err
        (when (or (eq major-mode 'c++-mode)
                  (eq major-mode 'lisp++-mode))
          (goto-char (point-min))
          (while (re-search-forward "\\(^\\|[^a-zA-Z0-9_]\\)\\(\\(global\\|GLOBAL\\)[a-zA-Z0-9_+-]*\\)\\([^a-zA-Z0-9_]\\)" nil t)
            (if (not (d-latexize--inside-comment-or-string))
                (replace-match "\\1(7cxxglbl){(2zz)color{glbl}{\\2}}(7cxxlblg)\\4" 'fixedcase)
              )))
      (error (message "Error 78! err=%s" err)))

    (checkpoint "checkpoint:79")

    (condition-case err
        (when (eq major-mode 'emacs-lisp-mode)
          (goto-char (point-min))
          (while (re-search-forward "\\(^\\|[^-a-zA-Z0-9_]\\)\\(\\(prop\\|PROP\\)[-a-zA-Z0-9_]*\\)\\([^-a-zA-Z0-9_]\\)" nil t)
            (if (not (d-latexize--inside-comment-or-string))
                (replace-match "\\1{(2zz)color{przp}{\\2}}\\4" 'fixedcase)
              )))
      (error (message "Error 79! err=%s" err)))

    (checkpoint "checkpoint:81")

    (condition-case err
        (when (or (eq major-mode 'c++-mode)
                  (eq major-mode 'lisp++-mode))
          (goto-char (point-min))
          (while (re-search-forward "\\(^\\|[^a-zA-Z0-9_]\\)\\(dmp\\|std\\)::" nil t)
            (if (and (not (d-latexize--inside-comment))
                     (not (d-latexize--inside-string)))
                (replace-match "\\1(7cxxredc){(2zz)color{red}{\\2}}::(7cxxcder)" 'fixedcase)
              )))
      (error (message "Error 81! err=%s" err)))

    (checkpoint "checkpoint:82")

    (condition-case err
        (when (eq major-mode 'c++-mode)
          (goto-char (point-min))
          (while (re-search-forward "\\(^\\|[^a-zA-Z0-9_-]\\)\\(\\(prop\\|PROP\\)[a-zA-Z0-9_]*\\)\\([^a-zA-Z0-9_-]\\)" nil t)
            (if (not (d-latexize--inside-comment-or-string))
                (replace-match "\\1{(2zz)color{przp}{\\2}}\\4" 'fixedcase)
              )))
      (error (message "Error 82! err=%s" err)))

    (checkpoint "checkpoint:82b")

    (condition-case err
        (when (eq major-mode 'lisp++-mode)
          (goto-char (point-min))
          (while (re-search-forward "(cnamespace \\([a-z]+\\)" nil t)
            (if (not (d-latexize--inside-comment-or-string))
                (replace-match "(cnamespace {(2zz)color{red}{\\1}}" 'fixedcase)
              )))
      (error (message "Error 82b! err=%s" err)))

    (checkpoint "checkpoint:83")

    (let (str)
      (setq str (concat
                 "\\([^.a-zA-Z0-9_-]\\)\\(c-[-a-zA-Z0-9_+*<>]*\\|cret\\|ctype\\|"
                 "cname\\|cargs?\\|cinit\\|cprogn\\|"
                 "cmethod\\|cproperty\\|cpause\\|"
                 "cfor\\|cforever\\|cwhile\\|cdo\\|cfunction\\|"
                 "c-public-extends\\|c-private-extends\\|"
                 "cautogc\\|c-autogc-multi\\|c-autogc-both\\|"
                 "cif[?]?\\|celseif\\|celse\\|"
                 "cswitch\\|cbrackets\\|d-quote\\|"
                 "cenum\\|citems\\|citem\\|cinline\\|"
                 "cdefine\\|cglobal\\|cclass\\|"
                 "s\\|f\\|sc\\|clet[*]?\\|cassert\\|"
                 "c-raw-c++\\|c-raw-h++\\|c-raw-global-h++\\|"
                 "cnamespace\\|cfriend\\|ctypedef\\|cpublic\\|"
                 "cprivate\\|cprotected\\)\\([^.a-zA-Z0-9_-]\\)"))

      (condition-case err
          (progn
            (goto-char (point-min))
            (while (re-search-forward str nil t)
              (if (not (d-latexize--inside-comment-or-string))
                  (replace-match "\\1(7cxxgrnc){(2zz)color{green-keyw}{\\2}}(7cxxcnrg)\\3" 'fixedcase)
                )))
        (error (message "Error 83! err=%s" err)))
      (checkpoint "checkpoint:84")
      (condition-case err
          (when (or (eq major-mode 'c++-mode)
                    (eq major-mode 'lisp++-mode))
            (goto-char (point-min))
            (while (re-search-forward str nil t)
              (if (progn
                    (not (d-latexize--inside-comment-or-string)))
                  (replace-match "\\1(7cxxgrnc){(2zz)color{green-keyw}{\\2}}(7cxxcnrg)\\3" 'fixedcase)
                )))
        (error (message "Error 84! err=%s" err)))
      (checkpoint "checkpoint:85")
      (condition-case err
          (when (or (eq major-mode 'c++-mode)
                    (eq major-mode 'lisp++-mode))
            (goto-char (point-min))
            (while (re-search-forward str nil t)
              (if (progn
                    (d-goto-char-safe (- (point) 2))
                    (not (d-latexize--inside-comment-or-string)))
                  (replace-match "\\1(7cxxgrnc){(2zz)color{green-keyw}{\\2}}(7cxxcnrg)\\3" 'fixedcase)
                )))
        (error (message "Error 85! err=%s" err)))
      (checkpoint "checkpoint:86")
      )

    (condition-case err
        (when (eq major-mode 'emacs-lisp-mode)
          (goto-char (point-min))
          (while (re-search-forward "\\*[a-zA-Z_][a-zA-Z0-9]*\\*" nil t)
            (if (not (d-latexize--inside-comment-or-string))
                (replace-match "{(2zz)color{green}{\\&}}" 'fixedcase)
              )))
      (error (message "Error 86! err=%s" err)))

    (checkpoint "checkpoint:87")

    (condition-case err
        (when (or (eq major-mode 'lisp++-mode)
                  (eq major-mode 'emacs-lisp-mode))
          (goto-char (point-min))
          (while (re-search-forward "\\<\\(c-basic-offset\\|c-mode\\)\\>" nil t)
            (if (and (not (d-latexize--inside-string))
                     (not (d-latexize--inside-comment)))
                (replace-match "{(2zz)color{black}{\\&}}" 'fixedcase)
              )))
      (error (message "Error 87! err=%s" err)))

    (checkpoint "checkpoint:88")

    (condition-case err
        (when (or (eq major-mode 'lisp++-mode)
                  (eq major-mode 'emacs-lisp-mode))
          (goto-char (point-min))
          (while (re-search-forward "\\(^\\|[^-a-zA-Z0-9_]\\)\\(\\<\\(prop\\|PROP\\|LOCAL\\|local\\)[-a-zA-Z0-9_]*\\>\\)" nil t)
            (if (and (not (d-latexize--inside-string))
                     (not (d-latexize--inside-comment)))
                (replace-match "\\1{(2zz)color{orange}{\\2}}" 'fixedcase)
              )))
      (error (message "Error 88! err=%s" err)))

    (checkpoint "checkpoint:89")

    (condition-case err
        (when (eq major-mode 'emacs-lisp-mode)
          (goto-char (point-min))
          (while (re-search-forward "&[a-zA-Z_][-a-zA-Z0-9_]*" nil t)
            (when (not (d-latexize--inside-comment-or-string))
              (replace-match "{(2zz)bf(2zz)color{red}{\\&}}" 'fixedcase)
              )))
      (error (message "Error 89! err=%s" err)))

    (checkpoint "checkpoint:90")

    (condition-case err
        (when (eq major-mode 'emacs-lisp-mode)
          (goto-char (point-min))
          (while (re-search-forward (concat "\\<\\(defvar\\|defmacro\\|defun\\|let\\*?"
                                            "\\|if\\|when\\|while\\|save-excursion\\|progn"
                                            "\\|unwind-protect\\|condition-case"
                                            "\\|with-temp-buffer\\|"
                                            "\\|save-match-data\\)\\>") nil t)
            (when (not (d-latexize--inside-comment-or-string))
              (replace-match "{(2zz)bf{\\&}}" 'fixedcase)
              )))
      (error (message "Error 90! err=%s" err)))

    (checkpoint "checkpoint:91")

    (condition-case err
        (progn
          (goto-char (point-min))
          (while (re-search-forward "\\([^-a-zA-Z0-9_]\\)\\(-?[0-9]+\\(\\.[0-9]+\\)?\\)\\([^a-zA-Z0-9_]\\)" nil t)
            (when (save-excursion
                    (d-goto-char-safe (- (point) 1))
                    (not (d-latexize--inside-comment-or-string)))
              (replace-match "\\1(7cxxnumb){(2zz)color{numb}{\\2}}(7cxxbmun)\\4" 'fixedcase)
              (d-goto-char-safe (- (point) 1)))))
      (error (message "Error 91! err=%s" err)))

    (checkpoint "checkpoint:92")

    (condition-case err
        (progn
          (goto-char (point-min))
          (while (re-search-forward "\\([^-a-zA-Z0-9_]\\)\\(0[Xx][0-9A-Fa-f]+\\)\\([^-a-zA-Z0-9_]\\)" nil t)
            (when (save-excursion ;;0xDEADBEEF
                    (d-goto-char-safe (- (point) 2))
                    (not (d-latexize--inside-comment-or-string)))
              (replace-match "\\1{(2zz)color{numb}{\\2}}\\3" 'fixedcase)
              )))
      (error (message "Error 92! err=%s" err)))

    (checkpoint "checkpoint:93")

    (condition-case err
        (when (or (eq major-mode 'lisp++-mode)
                  (eq major-mode 'emacs-lisp-mode))
          (goto-char (point-min))
          (while (re-search-forward "\\<\\(c-basic-offset\\|c-mode\\)\\>" nil t)
            (if (and (not (d-latexize--inside-string))
                     (not (d-latexize--inside-comment)))
                (replace-match "{(2zz)color{black}{\\&}}" 'fixedcase)
              )))
      (error (message "Error 94! err=%s" err)))

    (checkpoint "checkpoint:95")

    (condition-case err
        (when (or (eq major-mode 'lisp++-mode)
                  (eq major-mode 'emacs-lisp-mode))
          (goto-char (point-min))
          (while (re-search-forward "\\(^\\|[^-a-zA-Z0-9_]\\)\\(\\<\\(prop\\|PROP\\|LOCAL\\|local\\)[-a-zA-Z0-9_]*\\>\\)" nil t)
            (if (and (not (d-latexize--inside-string))
                     (not (d-latexize--inside-comment)))
                (replace-match "\\1{(2zz)color{orange}{\\2}}" 'fixedcase)
              )))
      (error (message "Error 95! err=%s" err)))

    (checkpoint "checkpoint:96")

    (condition-case err
        (progn
          (goto-char (point-min))
          (while (re-search-forward "<" nil t)
            (replace-match "(3QQ)<(3QQ)" 'fixedcase)
            ))
      (error (message "Error 96! err=%s" err)))

    (checkpoint "checkpoint:96b")

    (condition-case err
        (progn
          (goto-char (point-min))
          (while (re-search-forward ">" nil t)
            (replace-match "(3QQ)>(3QQ)" 'fixedcase)
            ))
      (error (message "Error 96b! err=%s" err)))

    (checkpoint "checkpoint:97")

    (condition-case err
        (progn
          (goto-char (point-min))
          (while (re-search-forward "|" nil t)
            (replace-match "(3QQ)|(3QQ)" 'fixedcase)
            ))
      (error (message "Error 97! err=%s" err)))

    (checkpoint "checkpoint:98")

    (condition-case err
        (progn
          (goto-char (point-min))
          (while (re-search-forward "\\^" nil t)
            (replace-match "(2zz)^{}" 'fixedcase)
            ))
      (error (message "Error 98! err=%s" err)))

    (checkpoint "checkpoint:101")

    (condition-case err
        (progn
          (goto-char (point-min))
          (while (re-search-forward "\\<m4_[a-zA-Z0-9_]*" nil t)
            (setq str (buffer-substring-no-properties (match-beginning 0) (match-end 0)))
            (if (and (not (string= str (concat "m4" "_dnl")))
                     (not (d-latexize--inside-comment-or-string)))
                (replace-match "(7cxxprvt){(2zz)colorbox{prvt}{\\&}}(7cxxtvrp)" 'fixedcase)
              )))
      (error (message "Error 101! err=%s" err)))

    (checkpoint "checkpoint:102")

    (condition-case err
        (progn
          (goto-char (point-min))
          (while (re-search-forward "\\\\" nil t)
            (replace-match "(3QQ)(2zz)backslash(3QQ)" 'fixedcase)
            ))
      (error (message "Error 102! err=%s" err)))

    (checkpoint "checkpoint:103")

    (condition-case err
        (progn
          ;;(message "*target*=%s" *target*)
          (when (string-match "\\.m4$" *target*)
            (goto-char (point-min))
            (while (re-search-forward "(3QQ)(2zz)backslash(3QQ)\\([a-z0-9]+\\)" nil t)
              (if (not (d-latexize--inside-comment-or-string))
                  (replace-match "(3QQ)(2zz)backslash(3QQ){(2zz)bf{\\1}}" 'fixedcase)
                ))))
      (error (message "Error 103! err=%s" err)))

    (checkpoint "checkpoint:104")

    (condition-case err ;; FOCK! me here
        (progn
          (goto-char (point-min))
          (while (search-forward "(3QQ)" nil t)
            (replace-match "$" 'fixedcase)
            ))
      (error (message "Error 105! err=%s" err)))

    (checkpoint "checkpoint:106")

    (condition-case err
        (progn
          (goto-char (point-min))
          (while (re-search-forward "\\<\\(NOTE[A-Z ]*:\\)\\(.*$\\)" nil t)
            (if (not (d-latexize--inside-string))
                (replace-match "{(2zz)bf(2zz)color{black}(2zz)colorbox{orange}{\\1}}{(2zz)bf(2zz)color{orange}{\\2}}" 'fixedcase)
              )))
      (error (message "Error 106! err=%s" err)))

    (checkpoint "checkpoint:107")

    (condition-case err
        (progn
          (goto-char (point-min))
          (while (re-search-forward "\\<\\(PRINTS[A-Z ]*:\\)\\(.*$\\)" nil t)
            (if (not (d-latexize--inside-string))
                (replace-match "{(2zz)bf(2zz)color{black}(2zz)colorbox{orange}{\\1}}{(2zz)bf(2zz)color{orange}{\\2}}" 'fixedcase)
              )))
      (error (message "Error 107! err=%s" err)))

    (checkpoint "checkpoint:108")

    (condition-case err
        (progn
          (goto-char (point-min))
          (while (re-search-forward "\\<\\(USED[A-Z ]*:\\)\\(.*$\\)" nil t)
            (if (not (d-latexize--inside-string))
                (replace-match "{(2zz)bf(2zz)color{black}(2zz)colorbox{orange}{\\1}}{(2zz)bf(2zz)color{orange}{\\2}}" 'fixedcase)
              )))
      (error (message "Error 108! err=%s" err)))

    (checkpoint "checkpoint:109")

    (condition-case err
        (progn
          (goto-char (point-min))
          (while (re-search-forward "\\<\\(DISALLOW[A-Z ]*:\\)\\(.*$\\)" nil t)
            (if (not (d-latexize--inside-string))
                (replace-match "{(2zz)bf(2zz)color{black}(2zz)colorbox{orange}{\\1}}{(2zz)bf(2zz)color{orange}{\\2}}" 'fixedcase)
              )))
      (error (message "Error 109! err=%s" err)))

    (checkpoint "checkpoint:110")

    (condition-case err
        (progn
          (goto-char (point-min))
          (while (re-search-forward "\\<\\(this[A-Z ]*:\\)\\(.*$\\)" nil t)
            (if (not (d-latexize--inside-string))
                (replace-match "{(2zz)bf(2zz)color{black}(2zz)colorbox{orange}{\\1}}{(2zz)bf(2zz)color{orange}{\\2}}" 'fixedcase)
              )))
      (error (message "Error 110! err=%s" err)))

    (checkpoint "checkpoint:111")

    (condition-case err
        (progn
          (goto-char (point-min))
          (while (re-search-forward "\\<COOL:\\(.*$\\)" nil t)
            (if (not (d-latexize--inside-string))
                (replace-match "{(2zz)bf(2zz)color{black}(2zz)colorbox{light-green}{COOL:}}{(2zz)bf(2zz)color{green-keyw}{\\1}}" 'fixedcase)
              )))
      (error (message "Error 111! err=%s" err)))

    (checkpoint "checkpoint:112")

    (condition-case err
        (when (eq major-mode 'emacs-lisp-mode)
          (goto-char (point-min))
          (while (re-search-forward "checkpoint" nil t)
            (if (not (d-latexize--inside-comment-or-string))
                (replace-match "{(2zz)color{vari}{checkpoint}}" 'fixedcase)
              )))
      (error (message "Error 113! err=%s" err)))

    (checkpoint "checkpoint:114")

    (condition-case err
        (let ((case-fold-search nil)
              str str-line)
          (when (eq major-mode 'tes-mode)
            (goto-char (point-min))
            (while (re-search-forward (concat "\\<\\(m4" "_dnl\\)\\>\\(.*$\\)") nil t)
              (when (not (d-latexize--inside-comment-or-string))
                (setq str-line (buffer-substring-no-properties (match-beginning 0) (point-at-eol)))
                (message "m4 preprocessor: str-line=%s" str-line)
                (replace-match "(7cxxclss){(2zz)colorbox{d-face-m4-dnl}{\\1}}{(2zz)color{comm}{\\2}}" 'fixedcase)
                (end-of-line)
                ))
            (goto-char (point-min))
            (while (re-search-forward "\\<\\(M4_[A-Z0-9_]*\\)\\>" nil t)
              (setq str (buffer-substring-no-properties (match-beginning 1) (match-end 1)))
              (message "m4 preprocessor: str=%s" str)
              (when (not (d-latexize--inside-comment-or-string))
                (replace-match (format "(7cxxclss){(2zz)colorbox{m4-col}{%s}}(7cxxsslc)" str) 'fixedcase)
                ))
            )) ;; END LET!
          (error (message "Error 114! err=%s" err)))

    (checkpoint "checkpoint:115")

    (condition-case err
        (progn
          (goto-char (point-min))
          (while (re-search-forward "_" nil t)
            (replace-match "(2zz)_" 'fixedcase)
            ))
      (error (message "Error 115! err=%s" err)))

    (checkpoint "checkpoint:116")

    (condition-case err
        (progn
          (goto-char (point-min))
          (while (re-search-forward "~" nil t)
            (replace-match "(2zz)~{}" 'fixedcase)
            ))
      (error (message "Error 116! err=%s" err)))

    (checkpoint "checkpoint:117")

    (condition-case err
        (progn
          (goto-char (point-min))
          (while (re-search-forward "&" nil t)
            (replace-match "\\\\&" 'fixedcase)
            ))
      (error (message "Error 117! err=%s" err)))

    (checkpoint "checkpoint:118")

    (condition-case err
        (progn
          (goto-char (point-min))
          (while (re-search-forward "#" nil t)
            (replace-match "\\\\#" 'fixedcase)
            ))
      (error (message "Error 118! err=%s" err)))

    (checkpoint "checkpoint:119")

    (condition-case err
        (progn
          (goto-char (point-min))
          (while (re-search-forward "%" nil t)
            (replace-match "\\\\%" 'fixedcase)
            ))
      (error (message "Error 119! err=%s" err)))

    (checkpoint "checkpoint:120")
    (setq cull-spaces t)
    (when cull-spaces
      (checkpoint "checkpoint:121")
      (condition-case err
          (let (count)
            (setq count 0)
            (goto-char (point-min))
            (setq quoted-dollar (regexp-quote "$"))
            (setq count-plus-100 (+ count 100))
            (while (re-search-forward " " nil t)
              (when (save-match-data
                      (and (save-excursion
                             (d-goto-char-safe (- (point) 1))
                             (not (looking-at quoted-dollar)))
                           (not (looking-at quoted-dollar))))
                (replace-match "\\\\p{}" 'fixedcase)
                (when (> count count-plus-100)
                  (checkpoint (format "checkpoint:114 %s%%" (/ (* 100 (point)) (point-max))))
                  (setq count-plus-100 (+ count 100)))
                (incf count)
                )))
        (error (message "Error 121! err=%s" err)))
      )

    (checkpoint "checkpoint:122")

    (condition-case err
        (progn
          (goto-char (point-min))
          (while (re-search-forward "(2zz)" nil t)
            (replace-match "\\\\" 'fixedcase)
            ))
      (error (message "Error 122! err=%s" err)))

    (checkpoint "checkpoint:123")

    (condition-case err
        (progn
          (goto-char (point-min))
          (while (and (re-search-forward "^.+$" nil t) (not (eobp)))
            (replace-match "\\\\noindent \\& \\\\\\\\" 'fixedcase)
            (d-goto-char-safe (- (point) 1))
            ))
      (error (message "Error 123! err=%s" err)))

    (checkpoint "checkpoint:124")

    (setq cull-cxx t)
    (when cull-cxx

      (condition-case err
          (progn
            (goto-char (point-min))
            (while (search-forward "(7cxxcomm)" nil t)
              (replace-match "" 'fixedcase)
              )
            (goto-char (point-min))
            (while (search-forward "(7cxxmmoc)" nil t)
              (replace-match "" 'fixedcase)
              ))
        (error (message "Error 124! err=%s" err)))

      (checkpoint "checkpoint:125")

      (condition-case err
          (progn
            (goto-char (point-min))
            (while (search-forward "(7cxxstri)" nil t)
              (replace-match "" 'fixedcase)
              )
            (goto-char (point-min))
            (while (search-forward "(7cxxirts)" nil t)
              (replace-match "" 'fixedcase)
              ))
        (error (message "Error 125! err=%s" err)))

      (checkpoint "checkpoint:126")

      (condition-case err
          (progn
            (goto-char (point-min))
            (while (search-forward "(7cxxfunc)" nil t)
              (replace-match "" 'fixedcase)
              )
            (goto-char (point-min))
            (while (search-forward "(7cxxcnuf)" nil t)
              (replace-match "" 'fixedcase)
              ))
        (error (message "Error 126! err=%s" err)))

      (checkpoint "checkpoint:127")

      (condition-case err
          (progn
            (goto-char (point-min))
            (while (search-forward "(7cxxhash)" nil t)
              (replace-match "" 'fixedcase)
              )
            (goto-char (point-min))
            (while (search-forward "(7cxxhsah)" nil t)
              (replace-match "" 'fixedcase)
              ))
        (error (message "Error 127! err=%s" err)))

      (checkpoint "checkpoint:128")

      (condition-case err
          (progn
            (goto-char (point-min))
            (while (search-forward "(7cxxprvt)" nil t)
              (replace-match "" 'fixedcase)
              )
            (goto-char (point-min))
            (while (search-forward "(7cxxtvrp)" nil t)
              (replace-match "" 'fixedcase)
              ))
        (error (message "Error 128! err=%s" err)))

      (checkpoint "checkpoint:129")

      (condition-case err
          (progn
            (goto-char (point-min))
            (while (search-forward "(7cxxglbl)" nil t)
              (replace-match "" 'fixedcase)
              )
            (goto-char (point-min))
            (while (search-forward "(7cxxlblg)" nil t)
              (replace-match "" 'fixedcase)
              ))
        (error (message "Error 129! err=%s" err)))

      (checkpoint "checkpoint:130")

      (condition-case err
          (progn
            (goto-char (point-min))
            (while (search-forward "(7cxxjtw)" nil t)
              (replace-match "" 'fixedcase)
              )
            (goto-char (point-min))
            (while (search-forward "(7cxxwtj)" nil t)
              (replace-match "" 'fixedcase)
              ))
        (error (message "Error 130! err=%s" err)))

      (checkpoint "checkpoint:131")

      (condition-case err
          (progn
            (goto-char (point-min))
            (while (search-forward "(7cxxvari)" nil t)
              (replace-match "" 'fixedcase)
              )
            (goto-char (point-min))
            (while (search-forward "(7cxxirav)" nil t)
              (replace-match "" 'fixedcase)
              ))
        (error (message "Error 131! err=%s" err)))

      (checkpoint "checkpoint:132")

      (condition-case err
          (progn
            (goto-char (point-min))
            (while (search-forward "(7cxxclss)" nil t)
              (replace-match "" 'fixedcase)
              )
            (goto-char (point-min))
            (while (search-forward "(7cxxsslc)" nil t)
              (replace-match "" 'fixedcase)
              ))
        (error (message "Error 132! err=%s" err)))

      (checkpoint "checkpoint:133")

      (condition-case err
          (progn
            (goto-char (point-min))
            (while (search-forward "(7cxxgrnc)" nil t)
              (replace-match "" 'fixedcase)
              )
            (goto-char (point-min))
            (while (search-forward "(7cxxcnrg)" nil t)
              (replace-match "" 'fixedcase)
              ))
        (error (message "Error 133! err=%s" err)))

      (checkpoint "checkpoint:134")

      (condition-case err
          (progn
            (goto-char (point-min))
            (while (search-forward "(7cxxredc)" nil t)
              (replace-match "" 'fixedcase)
              )
            (goto-char (point-min))
            (while (search-forward "(7cxxcder)" nil t)
              (replace-match "" 'fixedcase)
              ))
        (error (message "Error 134! err=%s" err)))

      (checkpoint "checkpoint:135")

      (condition-case err
          (progn
            (goto-char (point-min))
            (while (re-search-forward "(7cxxnumb)" nil t)
              (replace-match "" 'fixedcase)
              )
            (goto-char (point-min))
            (while (re-search-forward "(7cxxbmun)" nil t)
              (replace-match "" 'fixedcase)
              ))
        (error (message "Error 136! err=%s" err)))

      (checkpoint "checkpoint:137")

      (condition-case err
          (progn
            (goto-char (point-min))
            (while (re-search-forward "{przp}" nil t)
              (replace-match "{prop}" 'fixedcase)
              ))
        (error (message "Error 137! err=%s" err)))

      (checkpoint "checkpoint:138")

      (condition-case err
          (progn
            (goto-char (point-min))
            (while (re-search-forward "(7cxxllll)" nil t)
              (replace-match "L" 'fixedcase)
              ))
        (error (message "Error 138! err=%s" err)))

      )

    (checkpoint "checkpoint:139")

    (write-file (concat *target* ".tex"))
    (kill-buffer *buf*)

    (message "*** end of d-latexize7.el")
    ))

(provide 'd-latexize7)

Back
| Main Menu | Research Projects | Photo Album | Curriculum Vitae | The Greatest Artists |
| Email Address | Computer Games | Web Design | Java Training Wheels | The Fly (A Story) |
| Political Activism | Bob Dylan Quotes+ | My Life Story | Smoking Cessation | Other Links |
| Debugging Macros | String Class I | Linked List System I | Java for C Programmers | Naming Convention |
| String Class II | How I use m4 | Strings III | Symmetrical I/O | Linked Lists II |
| Run-Time Type Info | Virtual Methods | An Array System | Science & Religion | Submodes |
| Nested Packages | Memory Leaks | Garbage Collection | Internet & Poverty | What is Knowledge? |
| Limits of Evolution | Emacs Additions | Function Plotter | Romantic Love | The Next Big Thing |
| Science Fiction | Faster Compilation | Theory of Morality | Elisp Scoping | Elisp Advice |
| S.O.G.M. Pattern | Safe Properties | School Bullying | Charisma Control | Life and Death |
| Splitting Java | Multiple Ctors | Religious Beliefs | Conversation 1 | Conversation 2 |
| J.T.W. Language | Emacs Additions II | Build Counter | Relation Plotter | Lisp++ Language |
| Memory Leaks II | Super Constructors | CRUD Implementation | Order a Website Form | There Is An Afterlife |
| More Occam's Razor | C to Java Translator | Theory of Morality II
Last modified: Sat Apr 29 18:35:57 NZST 2017
Best viewed at 800x600 or above resolution.
© Copyright 1999-2017 Davin Pearson.
Please report any broken links to