erlang_appwiz.el

OTP是开放电信平台的简称

;;;    -*- Emacs-Lisp -*- 
;;;    File:	erlang_appwiz.el  
;;;    Author:	Johan Bevermyr
;;;    Created:	Tue Dec  9 13:14:24 1997
;;;    Purpose:	Adds a simple application wizard to erlang.el.

;; OBS! Must be loaded before the erlang.el file is loaded. 
;; Add the following to your .emacs file before erlang.el is loaded.
;;
;;     (load "erlang_appwiz" t nil)
;;
;; Customisation of makefile generation:
;;
;; The templates for generating makefiles are stored in the 
;; variables erlang-skel-makefile-src and erlang-skel-makefile-middle.
;; 
;; These can be modified by setting the variables before or after this
;; file is loaded.
;; 
;; For example, to generate OTP-style make files:
;;
;;
;;(defvar erlang-skel-makefile-src 
;;  '((erlang-skel-include erlang-skel-nomodule-header)
;;    "CC_ROOT := $(shell pwd | sed 's/erts.*$$//')" n
;;    "AUTOCONF := $(CC_ROOT)/erts/autoconf" n
;;    "TARGET := $(shell $(AUTOCONF)/config.guess)"
;;    "include $(CC_ROOT)/internal_tools/make/$(TARGET)/otp.mk" n
;;    n
;;    "# ----------------------------------------------------" n
;;    "# Application version " n
;;    "# ----------------------------------------------------" n
;;    "include ../vsn.mk" n
;;    "VSN=$(KERNEL_VSN)" n
;;    n
;;    "# ----------------------------------------------------" n
;;    "# Release directory specification" n
;;    "# ----------------------------------------------------" n
;;    "RELEASE_PATH= ../../../release/$(TARGET)" n
;;    "RELSYSDIR = $(RELEASE_PATH)/lib/kernel-$(VSN)" n
;;    n
;;    "# ----------------------------------------------------" n
;;    "# Target Specs" n
;;    "# ----------------------------------------------------" n
;;    n
;;    "MODULES= " appwiz-erlang-modulename n
;;    n
;;    "HRL_FILES=" 
;;    n
;;    INTERNAL_HRL_FILES= appwiz-erlang-modulename "_sup.hrl" n
;;    n
;;    "ERL_FILES= $(MODULES:%=%.erl)" n
;;    n
;;    "TARGET_FILES= $(MODULES:%=$(EBIN)/%.$(EMULATOR)) $(APP_TARGET)" n
;;    n
;;    "APP_FILE= " appwiz-erlang-modulename ".app" n
;;    n
;;    "APP_SRC= $(APP_FILE).src" n
;;    "APP_TARGET= ../ebin/$(APP_FILE)" n
;;    n
;;    "# ----------------------------------------------------" n
;;    "# FLAGS						   " n
;;    "# ----------------------------------------------------" n
;;    "ERL_FLAGS += 					   " n
;;    "ERL_COMPILE_FLAGS += -I../include" n
;;    n
;;    "# ----------------------------------------------------" n
;;    "# Targets" n
;;    "# ----------------------------------------------------" n
;;    n
;;    "debug opt: $(TARGET_FILES)" n
;;    n
;;    "clean:" n
;;    "	rm -f $(TARGET_FILES) $(GEN_FILES)" n
;;    "	rm -f core" n
;;    n
;;    "docs:" n
;;    n
;;    "# ----------------------------------------------------" n
;;    "# Special Build Targets				   " n
;;    "# ----------------------------------------------------" n
;;    "							   " n
;;    "$(APP_TARGET): $(APP_SRC)				   " n
;;    "	sed -e 's;%VSN%;$(VSN);' $(APP_SRC) > $(APP_TARGET)" n
;;    "							   " n
;;    "# ----------------------------------------------------" n
;;    "# Release Target					   " n
;;    "# ----------------------------------------------------" n 
;;    "include $(CC_ROOT)/internal_tools/make/otp_release_targets.mk" n
;;    n
;;    "release_spec: opt" n
;;    "	$(INSTALL_DIR) $(RELSYSDIR)/src                        " n
;;    "	$(INSTALL_DATA) $(ERL_FILES) $(RELSYSDIR)/src	       " n
;;    "	$(INSTALL_DATA) $(INTERNAL_HRL_FILES) $(RELSYSDIR)/src " n
;;    "	$(INSTALL_DIR) $(RELSYSDIR)/include		       " n
;;    "	$(INSTALL_DATA) $(HRL_FILES) $(RELSYSDIR)/include      " n
;;    "	$(INSTALL_DIR) $(RELSYSDIR)/ebin		       " n
;;    "	$(INSTALL_DATA) $(TARGET_FILES) $(RELSYSDIR)/ebin      " n
;;    n
;;    "release_docs_spec:" n
;;    ))
;;    
;;  
;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; Erlang application wizard
;;

(defun erlang-application-wizard (directory name)
  "Creates all files and directories needed for an application.
The top-level directory is placed in DIRECTORY. NAME is used when 
creating the root directory and for naming application files."

  (interactive "DApplication root directory: \nsName of application: ")
  (let ((dir nil)
	(lastchar (substring directory (- (length directory) 1)))
	(apptype (completing-read "Type of application: "
				  '(("gen_server" 1)
				    ("gen_event" 2)
				    ("gen_fsm" 3)
				    ("other" 4))
				  nil t "gen_server"))
	(appname      nil)
	(apptemplate  nil)
	(apitemplate  nil)
	(extension nil))

    (if (string= lastchar "/")
	(setq dir directory)
      (setq dir (concat directory "/")))

    ;; determine type of application
    (cond ((string= apptype "gen_server")
	   (setq extension "_server")
	   (setq appname (concat name extension))
	   (setq apptemplate 'tempo-template-erlang-generic-server)
	   (setq apitemplate 'tempo-template-erlang-large-header))
	  ((string= apptype "gen_event")
	   (setq extension "_event")
	   (setq appname (concat name extension))
	   (setq apptemplate 'tempo-template-erlang-gen-event)
	   (setq apitemplate 'tempo-template-erlang-large-header))
	  ((string= apptype "gen_fsm")
	   (setq extension "_fsm")
	   (setq appname (concat name extension))
	   (setq apptemplate 'tempo-template-erlang-gen-fsm)
	   (setq apitemplate 'tempo-template-large-header))
	  (t
	   ;; use defaults _work
	   (setq extension "_work")
	   (setq appname (concat name extension))
	   (setq apptemplate 'tempo-template-erlang-large-header)
	   (setq apitemplate 'tempo-template-erlang-large-header)))

    (setq appwiz-erlang-modulename appname)
    (setq appwiz-erlang-ext extension)

    ;; create directories
    (make-directory (concat dir name "/" "src") t)
    (make-directory (concat dir name "/" "ebin") t)
    (make-directory (concat dir name "/" "include") t)
    
    ;; create directory content
    ;;;;;;;;; .erl 
    (find-file (concat dir name "/" "src/" name ".erl"))
    (funcall apitemplate)
    (insert "API module for the application " name ".")
    (save-buffer)

    ;;;;;;;;; _app.erl
    (find-file (concat dir name "/" "src/" name "_app.erl"))
    (tempo-template-erlang-application)
    (insert "Application callback module for the application " name ".")

    (let ((quotedname (erlang-add-quotes-if-needed
		       (concat name "_sup")))
	  (start (point)))
      (while (search-forward "'TopSupervisor':start_link" nil t)
	(replace-match (concat quotedname ":start_link") nil t))
      (goto-char start))

    (save-buffer)

    ;;;;;;;;; _sup.erl
    (find-file (concat dir name "/" "src/" name "_sup.erl"))
    (tempo-template-erlang-supervisor)
    (insert "Top level supervisor for the application " name ".")


    (let ((quotedname (erlang-add-quotes-if-needed appname))
	  (start (point)))
      (while (search-forward "'AName'" nil t)
	(replace-match quotedname nil t))
      (goto-char start))

    (let ((quotedname (erlang-add-quotes-if-needed appname))
	  (start (point)))
      (goto-char 0)
      (while (search-forward "'AMODULE'" nil t)
	(replace-match quotedname nil t))
      (goto-char start))

    (save-buffer)

    ;;;;;;;;; _sup.hrl
    (find-file (concat dir name "/" "src/" name "_sup.hrl"))
    (tempo-template-erlang-nomodule-header)
    (save-buffer)

    ;;;;;;;;; _(application).erl
    (find-file (concat dir name "/" "src/" appname ".erl"))
    (funcall apptemplate)
    (save-buffer)
    
    ;;;;;;;;; makefile (src)
    (find-file (concat dir name "/" "src/makefile"))
    (setq appwiz-erlang-modulename name)
    (setq appwiz-erlang-ext extension)
    (tempo-template-erlang-makefile-src)
    (insert "Makefile for application " name ".")
    (let ((start (point)))
      (goto-char 0)
      (while (search-forward "%" nil t)
	(replace-match "#" nil t))
      (goto-char start))
    (save-buffer)

    ;;;;;;;;; makefile (middle)
    (find-file (concat dir name "/" "makefile"))
    (tempo-template-erlang-makefile-middle)
    (insert "Makefile for application " name ".")
    (let ((start (point)))
      (goto-char 0)
      (while (search-forward "%" nil t)
	(replace-match "#" nil t))
      (goto-char start))
    (save-buffer)

    ;;;;;;;;; .app
    (find-file (concat dir name "/" "ebin/" name ".app"))
    (erlang-mode)
    (tempo-template-erlang-app)
    (insert "Application specification file for " name ".")
    (save-buffer)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; These are setq:ed 
;;

(defvar appwiz-erlang-modulename "foo")
(defvar appwiz-erlang-ext "_work")

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;  Skeletons. 
;;  Skeletons for nomodule header and .app file added by JB.
;; 

(defvar erlang-skel
  '(("If"            "if"            erlang-skel-if)
    ("Case"          "case"          erlang-skel-case)
    ("Receive"       "receive"       erlang-skel-receive)
    ("Receive After" "after"         erlang-skel-receive-after)
    ("Receive Loop"  "loop"          erlang-skel-receive-loop)
    ("Module"        "module"        erlang-skel-module)
    ("Author"        "author"        erlang-skel-author)
    ("Query"         "query"         erlang-skel-query)
    ()
    ("Small Header"  "small-header" 
     erlang-skel-small-header erlang-skel-header)
    ("Normal Header" "normal-header"
     erlang-skel-normal-header erlang-skel-header)
    ("Large Header"  "large-header"
     erlang-skel-large-header erlang-skel-header)
    ("No Moudle Header"  "nomodule-header"
     erlang-skel-nomodule-header erlang-skel-header)
    ()
    ("Small Server"   "small-server"
     erlang-skel-small-server erlang-skel-header)
    ()
    ("application" "application"
     erlang-skel-application erlang-skel-header)
    ("app" "app"
     erlang-skel-app erlang-skel-header)
    ("supervisor" "supervisor"
     erlang-skel-supervisor erlang-skel-header)
    ("supervisor_bridge" "supervisor-bridge"
     erlang-skel-supervisor-bridge erlang-skel-header)
    ("gen_server" "generic-server"
     erlang-skel-generic-server erlang-skel-header)
    ("gen_event" "gen-event"
     erlang-skel-gen-event erlang-skel-header)
    ("gen_fsm" "gen-fsm"
     erlang-skel-gen-fsm erlang-skel-header))
  "*Description of all skeletons templates.
Both functions and menu entries will be created.

Each entry in `erlang-skel' should be a list with three or four
elements, or the empty list.

The first element is the name which shows up in the menu.  The second
is the `tempo' identfier (The string \"erlang-\" will be added in
front of it).  The third is the skeleton descriptor, a variable
containing `tempo' attributes as described in the function
`tempo-define-template'.  The optinal fourth elements denotes a
function which should be called when the menu is selected.

Functions corresponding to every template will be created.  The name
of the function will be `tempo-template-erlang-X' where `X' is the
tempo identifier as specified in the second argument of the elements
in this list.

A list with zero elemets means that the a horisontal line should
be placed in the menu.")  

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; Template for .app file skeleton
;;

(defvar erlang-skel-app
  '((erlang-skel-include erlang-skel-nomodule-header)
    "{application, "
    (erlang-add-quotes-if-needed (erlang-get-module-from-file-name)) "," n>
    "[{description, \"" (erlang-get-module-from-file-name) "\"}," n>
    "{vsn, \"0.1\"}," n>
    "{modules, ["
    (erlang-add-quotes-if-needed (erlang-get-module-from-file-name)) "," n>
    (erlang-add-quotes-if-needed
     (concat (erlang-get-module-from-file-name) "_app")) "," n>
    (erlang-add-quotes-if-needed
     (concat (erlang-get-module-from-file-name) "_sup")) "," n>
    (erlang-add-quotes-if-needed
     (concat (erlang-get-module-from-file-name) appwiz-erlang-ext)) "]}," n>
    "{registered, ["
    (erlang-add-quotes-if-needed
     (concat (erlang-get-module-from-file-name) appwiz-erlang-ext)) ","
    (erlang-add-quotes-if-needed
     (concat (erlang-get-module-from-file-name) "_sup")) "]}," n>
    "{applications, [kernel," n>
    "stdlib," n> 
    "sasl," n>
    "mnesia]}," n>
    "{env, []}," n>
    "{mod, {"
    (erlang-add-quotes-if-needed
     (concat (erlang-get-module-from-file-name) "_app"))
    ", []}}]}." n
    )
  "*The template of an application file
Please see the function `tempo-define-template'.")

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; Template for no-module header skeleton.
;;

(defvar erlang-skel-nomodule-header
  '(o (erlang-skel-separator)
      (erlang-skel-include erlang-skel-copyright-comment
			   erlang-skel-file-comment
			   erlang-skel-author-comment)
      "%%% Purpose : " p n
      (erlang-skel-include erlang-skel-created-comment)
      (erlang-skel-separator) n)
  "*The template of a normal header.
Please see the function `tempo-define-template'.")

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; .app extension added.
;;

(defvar erlang-file-name-extension-regexp "\\.\\(erl\\|hrl\\|app\\)$"
  "*Regexp which should match an erlang file name.

This regexp is used when an Erlang module name is extracted from the
name of an Erlang source file.

The regexp should only match the section of the file name which should
be excluded from the module name.

To match all files set this variable to \"\\\\(\\\\..*\\\\|\\\\)$\".
The matches all except the extension.  This is useful if the Erlang
tags system should interpretate tags on the form `module:tag' for
files written in other languages than Erlang.")

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; Wizard menu added. 
;;

(defvar erlang-menu-items
  '(("Indent"
     (("Indent Line" erlang-indent-command)
      ("Indent Region " erlang-indent-region 
       (if erlang-xemacs-p (mark) mark-active))
      ("Indent Clause" erlang-indent-caluse)
      ("Indent Function" erlang-indent-function)
      ("Indent Buffer" erlang-indent-current-buffer)))
    ("Edit"
     (("Fill Comment" erlang-fill-paragraph)
      ("Comment Region" comment-region
       (if erlang-xemacs-p (mark) mark-active))     
      ("Uncomment Region" erlang-uncomment-region
       (if erlang-xemacs-p (mark) mark-active))     
      nil
      ("beginning of Function" erlang-beginning-of-function)
      ("End of Function" erlang-end-of-function)
      ("Mark Function" erlang-mark-function)
      nil
      ("beginning of Clause" erlang-beginning-of-clause)
      ("End of Clause" erlang-end-of-clause)
      ("Mark Clause" erlang-mark-clause)
      nil
      ("New Clause" erlang-generate-new-clause)
      ("Clone Arguments" erlang-clone-arguments)))
    ("Font Lock Mode"
     (("Level 3" erlang-font-lock-level-3)
      ("Level 2" erlang-font-lock-level-2)
      ("Level 1" erlang-font-lock-level-1)
      ("Off" erlang-font-lock-level-0)))
    ("TAGS"
     (("Find Tag" find-tag)
      ("Find Next Tag" erlang-find-next-tag)
      ;("Find Regexp" find-tag-regexp)
      ("Complete Word" erlang-complete-tag)
      ("Tags Apropos" tags-apropos)
      ("Search Files" tags-search)))
    nil
    ("Erlang Shell" inferior-erlang-run-or-select)
    ("Compile" erlang-compile)
    ("Next Error" inferior-erlang-next-error)
    nil
    ("Version" erlang-version)
    nil
    ("Wizards" 
     (("Application Wizard" erlang-application-wizard))))
  "*Description of menu used in Erlang mode.

This variable must be a list. The elements are either nil representing
a horisontal line or a list with two or three elements.  The first is
the name of the menu item, the second is the function to call, or a
submenu, on the same same form as ITEMS.  The third optional argument
is an expression which is evaluated every time the menu is displayed.
Should the expression evaluate to nil the menu item is ghosted.