emerge -av graphviz

emerge -av graphivz-dot-mode

(load "graphviz-dot-mode.el" nil t t)
 
(add-hook 'find-file-hook (lambda()
                            (if (string= "dot" (file-name-extension
                                                buffer-file-name))
                                (progn
                                  (message "Enabling Setings for dot-mode")
                                  (setq fill-column 1000)
                                  (base-auto-pair)
                                  (local-set-key (kbd "<C-f6>") 'compile)
                                  )
                              )))

;; Function used to add fields of struct into a dot file (for Graphviz).
(defconst yyc/dot-head "subgraph cluster_%s {
    node [shape=record fontsize=12 fontname=Courier style=filled];
    color = lightgray;
    style=filled;
    label = \"Struct %s\";
    edge[color=\"#2e3436\"];"
  "Header part of dot file.")
(defconst yyc/dot-tail "
}"
  "Tail part of dot")
(defconst yyc/dot-node-head
  "
        node_%s[shape=record label=\"<f0>*** STRUCT %s ***|\\"
  "Format of node.")
(defconst yyc/dot-node-tail "
\"];"
  "Format of node.")
 
(defconst r_attr_str "[ \t]+\\(.*+\\)[ \t]+\\(.*\\)?;"
  "Regular expression for matching struct fields.")
 
(defconst r_name "\\_<\\(typedef[ \t]+\\)?struct[ \t]+\\(.*\\)?[ \t]*{"
  "Regular expression for mating struct name")
 
(defconst attr_str "
<f%d>%s %s\\l|\\" "nil")
 
(defun yyc/datastruct-to-dot (start end)
  "generate c++ function definition and insert it into `buffer'"
  (interactive "rp")
  (setq var-defination (buffer-substring-no-properties start end))
  (let* ((tmp_str "")
         (var-name "")
         (var-type "")
         (counter 0)
         (struct-name "")
         (header-str "")
         )
    (defun iter (pos)
      (setq counter (+ counter 1))
      (message (format "Counter: %d, pos: %d"
                       counter pos))
      (if (string-match r_name var-defination pos)
          (progn
            (message "A")
            (setq struct-name
                  (match-string 2 var-defination))
            (setq header-str
                  (format yyc/dot-head struct-name struct-name))
            (setq tmp_str
                  (format yyc/dot-node-head struct-name struct-name))
            (iter (match-end 0)))
        (if (string-match r_attr_str var-defination pos)
            (progn
              (message "B")
              (setq var-type
                    (match-string 1 var-defination))
              (setq var-name
                    (match-string 2 var-defination))
              (setq tmp_str
                    (concat tmp_str
                            (format attr_str counter var-type var-name)))
              (iter (match-end 0)))
          nil)))
    (save-excursion
      (iter 0)
      (set-buffer (get-buffer-create "tmp.dot"))
      (graphviz-dot-mode)
      (setq pos (point-max))
      (insert  header-str tmp_str )
      (goto-char (point-max))
      (delete-char -1)
      (insert "<f999>\\"yyc/dot-node-tail yyc/dot-tail)
      )
    (if (one-window-p)
        (split-window-vertically))
    (switch-to-buffer-other-window "tmp.dot")
    (goto-char (point-min))
    )
  (message "Finished, please see *tmp.dot* buffer.")
  )

(define-skeleton 1exp 
  "Input #+BEGIN_EXAMPLE #+END_EXAMPLE in org-mode"
""
"#+BEGIN_EXAMPLE\n"
 _ "\n" 
"#+END_EXAMPLE"
)
 
(define-abbrev org-mode-abbrev-table "iexp" "" '1exp)

(define-skeleton 1src 
  "Input #+begin_src #+end_src in org-mode"
""
"#+begin_src lisp \n"
 _ "\n" 
"#+end_src"
)
 
(define-abbrev org-mode-abbrev-table "isrc" "" '1src)

#+begin_src lisp 
 
#+end_src

(define-skeleton 1prop 
  "Input :PROPERTIES: :END: in org-mode"
""
>":PROPERTIES:\n"
> _ "\n" 
>":END:"
)
 
(define-abbrev org-mode-abbrev-table "iprop" "" '1prop)

(defun iexp (St Ed)
  "Enclose example for org-mode"
  (interactive "r")
  (let ((beg St) (end Ed))
    (message "%s %s" beg end)
    (i-babel-quote beg end "#+BEGIN_EXAMPLE" "#+END_EXAMPLE")))

(require-extensions 'require
 (list 
  'tabbar 
  'switch-window
  'thing-edit
  'second-sel
  'browse-kill-ring+
))

(defun isrc (St Ed)
  "Enclose code for org-mode"
  (interactive "r")
  (let ((beg St) (end Ed))
    (message "%s %s" beg end)
    (i-babel-quote beg end "#+begin_src " "#+end_src")))

(defun i-babel-quote (beg end str1 str2)
  (goto-char end)
  (forward-line 1)
  (insert str2)
  (newline)
  (goto-char beg)
  (forward-line -1)
  (newline)
  (insert str1)
)

(defun i= (St Ed)
  ""
  (interactive "r")
  (let ((beg St) (end Ed))
    (goto-char end)
    (insert "=")
    (goto-char beg)
    (insert "=")
    (goto-char (+ end 2)))
)

     (defun copy-word (&optional arg)
      "Copy words at point into kill-ring"
       (interactive "P")
       (copy-thing 'backward-word 'forward-word arg)
       (paste-to-mark arg)
     )

(global-set-key (kbd "C-c w")         (quote copy-word))

     (defun copy-line (&optional arg)
      "Save current line into Kill-Ring without mark the line "
       (interactive "P")
       (copy-thing 'beginning-of-line 'end-of-line arg)
       (paste-to-mark arg)
     )

(global-set-key (kbd "C-c l")         (quote copy-line))

     (defun copy-paragraph (&optional arg)
      "Copy paragraphes at point"
       (interactive "P")
       (copy-thing 'backward-paragraph 'forward-paragraph arg)
       (paste-to-mark arg)
     )

(global-set-key (kbd "C-c p")         (quote copy-paragraph))

     (defun beginning-of-string(&optional arg)
       "  "
       (re-search-backward "[ \t]" (line-beginning-position) 3 1)
             (if (looking-at "[\t ]")  (goto-char (+ (point) 1)) )
     )
     (defun end-of-string(&optional arg)
       " "
       (re-search-forward "[ \t]" (line-end-position) 3 arg)
             (if (looking-back "[\t ]") (goto-char (- (point) 1)) )
     )
 
     (defun thing-copy-string-to-mark(&optional arg)
       " Try to copy a string and paste it to the mark
     When used in shell-mode, it will paste string on shell prompt by default "
       (interactive "P")
       (copy-thing 'beginning-of-string 'end-of-string arg)
       (paste-to-mark arg)
     )

(global-set-key (kbd "C-c s")         (quote thing-copy-string-to-mark))

     (defun beginning-of-parenthesis(&optional arg)
       "  "
       (re-search-backward "[[<(?\"]" (line-beginning-position) 3 1)
             (if (looking-at "[[<(?\"]")  (goto-char (+ (point) 1)) )
     )
     (defun end-of-parenthesis(&optional arg)
       " "
       (re-search-forward "[]>)?\"]" (line-end-position) 3 arg)
             (if (looking-back "[]>)?\"]") (goto-char (- (point) 1)) )
     )
 
     (defun thing-copy-parenthesis-to-mark(&optional arg)
       " Try to copy a parenthesis and paste it to the mark
     When used in shell-mode, it will paste parenthesis on shell prompt by default "
       (interactive "P")
       (copy-thing 'beginning-of-parenthesis 'end-of-parenthesis arg)
       (paste-to-mark arg)
     )

(global-set-key (kbd "C-c a")         (quote thing-copy-parenthesis-to-mark))

     (defun get-point (symbol &optional arg)
      "get the point"
      (funcall symbol arg)
      (point)
     )
 
     (defun copy-thing (begin-of-thing end-of-thing &optional arg)
       "copy thing between beg & end into kill ring"
        (let ((beg (get-point begin-of-thing 1))
         (end (get-point end-of-thing arg)))
          (copy-region-as-kill beg end))
     )
 
     (defun paste-to-mark(&optional arg)
       "Paste things to mark, or to the prompt in shell-mode"
       (let ((pasteMe 
         (lambda()
           (if (string= "shell-mode" major-mode)
             (progn (comint-next-prompt 25535) (yank))
           (progn (goto-char (mark)) (yank) )))))
        (if arg
            (if (= arg 1)
            nil
              (funcall pasteMe))
          (funcall pasteMe))
        ))

; auto complete
(add-to-list 'load-path "/mydoc/lib/emacs-plugins/auto-complete")  
(require 'auto-complete-config)  
(add-to-list 'ac-dictionary-directories "/mydoc/lib/emacs-plugins/auto-complete/ac-dict")  
(ac-config-default)

(add-to-list 'load-path "~/Shell/config/emacs.el" "~/Shell/config/emacs.init")
 
(mapc 'load (directory-files "~/Shell/config/emacs.init" t "^[a-zA-Z0-9].*.el$"))

(custom-set-variables
  ;; custom-set-variables was added by Custom.
  ;; If you edit it by hand, you could mess it up, so be careful.
  ;; Your init file should contain only one such instance.
  ;; If there is more than one, they won't work right.
 '(ansi-color-faces-vector [default default default italic underline bold bold-italic modeline])
 '(ansi-color-names-vector ["black" "red" "PaleGreen" "yellow" "DodgerBlue1" "magenta" "cyan" "white"]))

(add-hook 'after-make-frame-functions
  (lambda(arg)
    (if  (>= (length (frame-list)) 1)
    (set-fontset-font  "fontset-startup" 'chinese-gbk (font-spec :family "文泉驿微米黑") nil 'prepend)
      )
    ) t
)

2 : 2023 : 13:03:26 : ~/Shell/config/emacs.init 
dove@bash-4.1$ du -sh *.el
8.0K    calendar-setup.el
28K color-theme.el
28K dove-ext.el
4.0K    keybindings.el
8.0K    org-mode.el
8.0K    plugins.el
4.0K    settings.el
 
2 : 2024 : 13:03:35 : ~/Shell/config/emacs.init 
dove@bash-4.1$ du -sh .emacs
4.0K    .emacs
 
2 : 2025 : 13:04:07 : ~/Shell/config/emacs.init 
dove@bash-4.1$

(eval-when-compile    (require 'color-theme))
 
(defun my-color-theme ()
  "Color theme created 2010-04-09."
;  (interactive)
  (color-theme-install
   '(my-color-theme
;     ((background-color . "#102C29")
     ((background-color . "darkslategrey")
;     (( background-color . "black")
      (background-mode . dark)
      (border-color . "black")
      (cursor-color . "LightGray")
;      ... ... ... ... theme 太长，中间省略了
     (woman-bold-face ((t (:bold t :weight bold))))
     (woman-italic-face ((t (:foreground "beige"))))
     (woman-unknown-face ((t (:foreground "LightSalmon"))))
     (zmacs-region ((t (:background "dark cyan" :foreground "cyan")))))))
 
(eval-when-compile (require 'color-theme))
(color-theme-initialize)
 
(add-hook 'after-make-frame-functions 
      (lambda (arg)
        ""
        (my-color-theme)) t)

(menu-bar-mode -1)
(tool-bar-mode -1)
(icomplete-mode 1)
(scroll-bar-mode -1)
;(ruler-mode -1)
 
(setq save-abbrevs t
      x-select-enable-clipboard               t
      ispell-dictionary                       "english"
      frame-title-format                      "%b %n %I"
      inhibit-startup-message                 t
      column-number-mode                      t
;         ... ... ... ... 内容太多，中间省略
      ido-toggle-regexp                       t
      dim:switch-window-relative              nil
      shell-file-name                         "/usr/bin/bash"
      default-major-mode                      'text-mode
)
 
;; Misc
(setq-default abbrev-mode                    t
          line-spacing                   4
)
 
(setenv "EMACSSHELL"                         shell-file-name)

(defun set-key-bindings (action bindingList)
  ""
  (mapcar (lambda(lst)
      ""
      (let ((x (car lst))
        (y (car (last lst))))
        (funcall action x y))) bindingList ))

(set-key-bindings 'global-set-key   
 (list 
     '([f2]                            calendar)
     '([(shift f2)]                    remember)
     '([f5]                            revert-buffer)
     '([f10]                           rename-buffer)
     '([f11]                           query-replace)
     '([(shift f11)]                   query-replace-regexp)
;         ... ... ... ... 按键太多，中间省略
     ;; copy paste operations 
     (list (kbd "C-=")                 'set-mark-command)
     (list (kbd "C-c l")               'copy-line)
     (list (kbd "C-c w")               'copy-word)
     (list (kbd "C-S-k")               (lambda()  " " (interactive) (kill-visual-line -1)))
     (list (kbd "C-c s")               'thing-copy-string-to-mark)
     (list (kbd "C-c a")               'thing-copy-parenthesis-to-mark)
     (list (kbd "C-c p")               'copy-paragraph)
     (list (kbd "C-x a d")             'delete-region)
;         ... ... ... ... 按键太多，中间省略
     (list (kbd "C-c c")               '(lambda() " " (interactive) (if emaci-mode  (emaci-mode-off) (emaci-mode-on))))
     (list (kbd "M-DEL")
       (lambda(&optional arg) 
         "Act as the obsolete dove-backward-kill-word " 
         (interactive "P")
         (if arg 
         (let ((arg (- 0 arg))) (dove-forward-kill-word arg))
           (dove-forward-kill-word -1))))
 
))

(defun require-extensions (action lst)
  ""
  (mapcar (lambda(ext) "" (funcall action ext)) lst))

(require-extensions 'require
 (list 
  'tabbar 
  'switch-window
  'thing-edit
  'second-sel
  'browse-kill-ring+
  'bbdb
  'gnuplot
  'muse-mode
  'ibuffer
  'w3m-load
  'rect-mark
  'ido
  'multi-term
  'lusty-explorer
  'oddmuse
  'emaci
  'move-text
  'uniquify
  'hide-region
))

(setq outline-minor-mode-list 
      (list '(emacs-lisp-mode "(defun")
        '(shell-mode ".*[bB]ash.*[#\$] ")
        '(sh-mode "function")
 
 ))

(defun set-outline-minor-mode-regexp ()
  ""
  (outline-minor-mode 1)
  (let ((regexp-list (append outline-minor-mode-list nil))
    (find-regexp
     (lambda (lst)
       ""
       (let ((innerList (car lst)))
         (if innerList
         (if (string= (car innerList) major-mode)
             (car (cdr innerList))
           (progn (pop lst)
              (funcall find-regexp lst))))
         ))))
         (make-local-variable 'outline-regexp)
         (setq outline-regexp (funcall find-regexp regexp-list)))
 
  (set-key-bindings 'local-set-key
            (list
             (list (kbd "C-c C-t") 'hide-body)
             (list (kbd "C-c C-a") 'show-all)
             (list (kbd "C-c C-e") 'show-entry)
;            (kbd "C-c C-d") 和 shell-mode 冲突，所以继续沿用 C-c @ C-d，不做自定义
             ))
)

 (add-hook 'shell-mode-hook 'set-outline-minor-mode-regexp t)
 (add-hook 'sh-mode-hook 'set-outline-minor-mode-regexp t)
 (add-hook 'emacs-lisp-mode-hook 'set-outline-minor-mode-regexp  t)

(define-skeleton iexp 
  "Input #+BEGIN_EXAMPLE #+END_EXAMPLE in org-mode"
""
"#+BEGIN_EXAMPLE\n"
 _ "\n" 
"#+END_EXAMPLE"
)
 
(define-skeleton isrc 
  "Input #+begin_src #+end_src in org-mode"
""
"#+begin_src lisp \n"
 _ "\n" 
"#+end_src"
)
 
(define-skeleton iprop 
  "Input :PROPERTIES: :END: in org-mode"
""
":PROPERTIES:\n"
 _ "\n" 
":END:"
)
 
(define-skeleton insert-emacser-code
  ""
  ""
  "#+BEGIN_HTML\n"
"<pre lang=\"lisp\" line=\"1\">\n"
 _"\n"
"

(defun i-babel-quote (beg end str1 str2)
  (goto-char end)
  (forward-line 1)
  (insert str2)
  (newline)
  (goto-char beg)
  (forward-line -1)
  (newline)
  (insert str1)
)
 
(defun iexp (St Ed)
  " "
  (interactive "r")
  (let ((beg St) (end Ed))
    (message "%s %s" beg end)
    (i-babel-quote beg end "#+BEGIN_EXAMPLE" "#+END_EXAMPLE")))
 
(defun isrc (St Ed)
  " "
  (interactive "r")
  (let ((beg St) (end Ed))
    (message "%s %s" beg end)
    (i-babel-quote beg end "#+begin_src " "#+end_src")))
(defun i= (St Ed)
  ""
  (interactive "r")
  (let ((beg St) (end Ed))
    (goto-char end)
    (insert "=")
    (goto-char beg)
    (insert "=")
    (goto-char (+ end 2)))
)

(define-skeleton kill-multiple-proces
  "Build killing multiple process command list"
  ""
  "ps -ef | grep -i " _ " | awk '{ print \"kill -9 \" $2 }'"
)
 
(define-abbrev shell-mode-abbrev-table "killps" "" 'kill-multiple-proces)
 
(define-skeleton gunzip-tar
  "unzip .tar.gz package in where -z is not available"
  ""
  "gunzip -cd " _ " | tar -xf - "
)
 
(define-skeleton def_listener 
  "Define a listener in a WMQ QMgr"
  ""
  "DEF LISTENER(LST) TRPTYPE(TCP) PORT(" _ ") CONTROL(QMGR)\n"
)
 
(define-abbrev shell-mode-abbrev-table "deflst" "" 'def_listener)
 
(define-skeleton def_clusrcvr
  "Define a Cluster Receiver Channel in a WMQ QMgr"
  ""
  "DEF CHL(TO.QMCOD.4.FTECA) CHLTYPE(CLUSRCVR) CONNAME('" _ "') CLUSTER(FTECA)\n"
)
 
(define-abbrev shell-mode-abbrev-table "defclusrcvr" "" 'def_clusrcvr)