The R13B03 release.OTP_R13B03

1 files changed, 1345 insertions, 0 deletions

diff --git a/lib/tools/emacs/erlang_appwiz.el b/lib/tools/emacs/erlang_appwiz.el
new file mode 100644
index 0000000000..ecbce66f47
--- /dev/null
+++ b/lib/tools/emacs/erlang_appwiz.el
@@ -0,0 +1,1345 @@
+;;;    -*- 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.
+
+Example:
+    '((\"Func1\" function-one)
+      (\"SubItem\" 
+       ((\"Yellow\" function-yellow)
+        (\"Blue\" function-blue)))
+      nil
+      (\"Region Funtion\" spook-function midnight-variable))
+
+Call the function `erlang-menu-init' after modifying this variable.")
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Prefixing space removed from date string
+;;
+
+(defun erlang-skel-d-mmm-yyyy ()
+  "Return the current date as a string in \"DD Mon YYYY\" form.
+The first character of DD is *not* space if the value is less than 10."
+  (let ((date (current-time-string)))
+    (format "%d %s %s"
+	    (string-to-int (substring date 8 10))
+	    (substring date 4 7)
+	    (substring date -4))))
+
+(defvar erlang-skel-date-function 'erlang-skel-d-mmm-yyyy
+  "*Function which returns date string.
+Look in the module `time-stamp' for a battery of functions.")
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Fixed skeletons. erlang-add-quotes-if-needed introduced where needed.
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Server templates.
+
+(defvar erlang-skel-small-server
+  '((erlang-skel-include erlang-skel-large-header)
+    "-export([start/0,init/1])." n n n
+    "start() ->" n> "spawn("
+    (erlang-add-quotes-if-needed (erlang-get-module-from-file-name))
+    ", init, [self()])." n n
+    "init(From) ->" n>
+    "loop(From)." n n
+    "loop(From) ->" n>
+    "receive" n>
+    p "_ ->" n>
+    "loop(From)" n>
+    "end."
+    )
+  "*Template of a small server.
+Please see the function `tempo-define-template'.")
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Behaviour templates.
+
+(defvar erlang-skel-application
+  '((erlang-skel-include erlang-skel-large-header)
+    "-behaviour(application)." n
+    n
+    "%% application callbacks" n
+    "-export([start/2, stop/1])." n n
+    (erlang-skel-separator)
+    "%%% Callback functions from application" n
+    (erlang-skel-separator)
+    n
+    (erlang-skel-separator 2)
+    "%% Func: start/2" n
+    "%% Returns: {ok, Pid}        |" n
+    "%%          {ok, Pid, State} |" n
+    "%%          {error, Reason}   " n
+    (erlang-skel-separator 2)
+    "start(Type, StartArgs) ->" n>
+    "case 'TopSupervisor':start_link(StartArgs) of" n>
+    "{ok, Pid} -> " n>
+    "{ok, Pid};" n>
+    "Error ->" n>
+    "Error" n>
+    "end." n
+    n
+    (erlang-skel-separator 2)
+    "%% Func: stop/1" n
+    "%% Returns: any "n
+    (erlang-skel-separator 2)
+    "stop(State) ->" n>
+    "ok." n
+    n
+    (erlang-skel-separator)
+    "%%% Internal functions" n
+    (erlang-skel-separator)
+    )
+  "*The template of an application behaviour.
+Please see the function `tempo-define-template'.")
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defvar erlang-skel-supervisor
+  '((erlang-skel-include erlang-skel-large-header)
+    "-behaviour(supervisor)." n
+    n
+    "%% External exports" n
+    "-export([start_link/1])." n
+    n
+    "%% supervisor callbacks" n
+    "-export([init/1])." n n
+    (erlang-skel-separator)
+    "%%% API" n
+    (erlang-skel-separator)
+    "start_link(StartArgs) ->" n>
+    "supervisor:start_link({local, " 
+    (erlang-add-quotes-if-needed (erlang-get-module-from-file-name)) "}, "
+    (erlang-add-quotes-if-needed (erlang-get-module-from-file-name)) 
+    ", StartArgs)." n 
+    n
+    (erlang-skel-separator)
+    "%%% Callback functions from supervisor" n
+    (erlang-skel-separator)
+    n
+    (erlang-skel-separator 2)
+    "%% Func: init/1" n
+    "%% Returns: {ok,  {SupFlags,  [ChildSpec]}} |" n
+    "%%          ignore                          |" n
+    "%%          {error, Reason}   " n
+    (erlang-skel-separator 2)
+    "init(StartArgs) ->" n>
+    "AChild = {'AName',{'AModule',start_link,[]}," n>
+    "permanent,2000,worker,['AModule']}," n>
+    "{ok,{{one_for_all,4,3600}, [AChild]}}." n
+    n
+    (erlang-skel-separator)
+    "%%% Internal functions" n
+    (erlang-skel-separator)
+    )
+  "*The template of an supervisor behaviour.
+Please see the function `tempo-define-template'.")
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defvar erlang-skel-supervisor-bridge
+  '((erlang-skel-include erlang-skel-large-header)
+    "-behaviour(supervisor_bridge)." n
+    n
+    "%% External exports" n
+    "-export([start_link/0])." n
+    n
+    "%% supervisor callbacks" n
+    "-export([init/1, terminate/2])." n n
+    "-record(state, {})." n 
+    n
+    (erlang-skel-separator)
+    "%%% API" n
+    (erlang-skel-separator)
+    "start_link() -> " n>
+    "supervisor_bridge:start_link({local, " 
+    (erlang-add-quotes-if-needed (erlang-get-module-from-file-name)) "}, "
+    (erlang-add-quotes-if-needed (erlang-get-module-from-file-name)) 
+    ", [])." n 
+    n
+    (erlang-skel-separator)
+    "%%% Callback functions from supervisor_bridge" n
+    (erlang-skel-separator)
+    n
+    (erlang-skel-separator 2)
+    "%% Func: init/1" n
+    "%% Returns: {ok,  Pid, State} |" n
+    "%%          ignore            |" n
+    "%%          {error, Reason}    " n
+    (erlang-skel-separator 2)
+    "init([]) ->" n>
+    "case 'AModule':start_link() of" n>
+    "{ok, Pid} ->" n>
+    "{ok, Pid, #state{}};" n>
+    "Error ->" n>
+    "Error" n>
+    "end." n
+    n
+    (erlang-skel-separator 2)
+    "%% Func: terminate/2" n
+    "%% Purpose: Synchronized shutdown of the underlying sub system." n
+    "%% Returns: any" n
+    (erlang-skel-separator 2)
+    "terminate(Reason, State) ->" n>
+    "'AModule':stop()," n>
+    "ok." n
+    n
+    (erlang-skel-separator)
+    "%%% Internal functions" n
+    (erlang-skel-separator)
+    )
+  "*The template of an supervisor_bridge behaviour.
+Please see the function `tempo-define-template'.")
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defvar erlang-skel-generic-server
+  '((erlang-skel-include erlang-skel-large-header)
+    "-behaviour(gen_server)." n
+    n
+    "%% External exports" n
+    "-export([start_link/0])." n
+    n
+    "%% gen_server callbacks" n
+    "-export([init/1, handle_call/3, handle_cast/2, "
+    "handle_info/2, terminate/2])." n n
+    "-record(state, {})." n 
+    n
+    (erlang-skel-separator)
+    "%%% API" n
+    (erlang-skel-separator)
+    "start_link() -> " n>
+    "gen_server:start_link({local, " 
+    (erlang-add-quotes-if-needed (erlang-get-module-from-file-name)) "}, "
+    (erlang-add-quotes-if-needed (erlang-get-module-from-file-name)) 
+    ", [], [])." n 
+    n
+    (erlang-skel-separator)
+    "%%% Callback functions from gen_server" n
+    (erlang-skel-separator)
+    n
+    (erlang-skel-separator 2)
+    "%% Func: init/1" n
+    "%% Returns: {ok, State}          |" n
+    "%%          {ok, State, Timeout} |" n
+    "%%          ignore               |" n
+    "%%          {stop, Reason}" n
+    (erlang-skel-separator 2)
+    "init([]) ->" n>
+    "{ok, #state{}}." n
+    n
+    (erlang-skel-separator 2)
+    "%% Func: handle_call/3" n
+    "%% Returns: {reply, Reply, State}          |" n
+    "%%          {reply, Reply, State, Timeout} |" n
+    "%%          {noreply, State}               |" n
+    "%%          {noreply, State, Timeout}      |" n
+    "%%          {stop, Reason, Reply, State}   | (terminate/2 is called)" n
+    "%%          {stop, Reason, State}            (terminate/2 is called)" n
+    (erlang-skel-separator 2)
+    "handle_call(Request, From, State) ->" n>
+    "Reply = ok," n>
+    "{reply, Reply, State}." n
+    n
+    (erlang-skel-separator 2)
+    "%% Func: handle_cast/2" n
+    "%% Returns: {noreply, State}          |" n
+    "%%          {noreply, State, Timeout} |" n
+    "%%          {stop, Reason, State}            (terminate/2 is called)" n
+    (erlang-skel-separator 2)    
+    "handle_cast(Msg, State) ->" n>
+    "{noreply, State}." n
+    n
+    (erlang-skel-separator 2)
+    "%% Func: handle_info/2" n
+    "%% Returns: {noreply, State}          |" n
+    "%%          {noreply, State, Timeout} |" n
+    "%%          {stop, Reason, State}            (terminate/2 is called)" n
+    (erlang-skel-separator 2)
+    "handle_info(Info, State) ->" n>
+    "{noreply, State}." n
+    n
+    (erlang-skel-separator 2)
+    "%% Func: terminate/2" n
+    "%% Purpose: Shutdown the server" n
+    "%% Returns: any (ignored by gen_server)" n
+    (erlang-skel-separator 2)
+    "terminate(Reason, State) ->" n>
+    "ok." n
+    n
+    (erlang-skel-separator)
+    "%%% Internal functions" n
+    (erlang-skel-separator)
+    )
+  "*The template of a generic server.
+Please see the function `tempo-define-template'.")
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defvar erlang-skel-gen-event
+  '((erlang-skel-include erlang-skel-large-header)
+    "-behaviour(gen_event)." n
+    n
+    "%% External exports" n
+    "-export([start_link/0, add_handler/0])." n
+    n
+    "%% gen_event callbacks" n
+    "-export([init/1, handle_event/2, handle_call/2, "
+    "handle_info/2, terminate/2])." n n
+    "-record(state, {})." n 
+    n
+    (erlang-skel-separator)
+    "%%% API" n
+    (erlang-skel-separator)
+    "start_link() ->" n>
+    "gen_event:start_link({local, " 
+    (erlang-add-quotes-if-needed (erlang-get-module-from-file-name)) "}). " n
+    n
+    "add_handler() ->" n>
+    "gen_event:add_handler("
+    (erlang-add-quotes-if-needed (erlang-get-module-from-file-name)) ", "
+    (erlang-add-quotes-if-needed (erlang-get-module-from-file-name)) 
+    ", [])." n 
+    n
+    (erlang-skel-separator)
+    "%%% Callback functions from gen_event" n
+    (erlang-skel-separator)
+    n
+    (erlang-skel-separator 2)
+    "%% Func: init/1" n
+    "%% Returns: {ok, State}          |" n
+    "%%          Other" n
+    (erlang-skel-separator 2)
+    "init([]) ->" n>
+    "{ok, #state{}}." n
+    n
+    (erlang-skel-separator 2)
+    "%% Func: handle_event/2" n
+    "%% Returns: {ok, State}                                |" n
+    "%%          {swap_handler, Args1, State1, Mod2, Args2} |" n
+    "%%          remove_handler                              " n
+    (erlang-skel-separator 2)
+    "handle_event(Event, State) ->" n>
+    "{ok, State}." n
+    n
+    (erlang-skel-separator 2)
+    "%% Func: handle_call/2" n
+    "%% Returns: {ok, Reply, State}                                |" n
+    "%%          {swap_handler, Reply, Args1, State1, Mod2, Args2} |" n
+    "%%          {remove_handler, Reply}                            " n
+    (erlang-skel-separator 2)
+    "handle_call(Request, State) ->" n>
+    "Reply = ok," n>
+    "{ok, Reply, State}." n
+    n
+    (erlang-skel-separator 2)
+    "%% Func: handle_info/2" n
+    "%% Returns: {ok, State}                                |" n
+    "%%          {swap_handler, Args1, State1, Mod2, Args2} |" n
+    "%%          remove_handler                              " n
+    (erlang-skel-separator 2)
+    "handle_info(Info, State) ->" n>
+    "{ok, State}." n
+    n
+    (erlang-skel-separator 2)
+    "%% Func: terminate/2" n
+    "%% Purpose: Shutdown the server" n
+    "%% Returns: any" n
+    (erlang-skel-separator 2)
+    "terminate(Reason, State) ->" n>
+    "ok." n
+    n
+    (erlang-skel-separator)
+    "%%% Internal functions" n
+    (erlang-skel-separator)
+    )
+  "*The template of a gen_event.
+Please see the function `tempo-define-template'.")
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defvar erlang-skel-gen-fsm
+  '((erlang-skel-include erlang-skel-large-header)
+    "-behaviour(gen_fsm)." n
+    n
+    "%% External exports" n
+    "-export([start_link/0])." n
+    n
+    "%% gen_fsm callbacks" n
+    "-export([init/1, state_name/2, state_name/3, handle_event/3," n>
+    "handle_sync_event/4, handle_info/3, terminate/3])." n n
+    "-record(state, {})." n 
+    n
+    (erlang-skel-separator)
+    "%%% API" n
+    (erlang-skel-separator)
+    "start_link() ->" n>
+    "gen_fsm:start_link({local, " 
+    (erlang-add-quotes-if-needed (erlang-get-module-from-file-name)) "}, "
+    (erlang-add-quotes-if-needed (erlang-get-module-from-file-name)) 
+    ", [], [])." n 
+    n
+    (erlang-skel-separator)
+    "%%% Callback functions from gen_fsm" n
+    (erlang-skel-separator)
+    n
+    (erlang-skel-separator 2)
+    "%% Func: init/1" n
+    "%% Returns: {ok, StateName, StateData}          |" n
+    "%%          {ok, StateName, StateData, Timeout} |" n
+    "%%          ignore                              |" n
+    "%%          {stop, StopReason}                   " n
+    (erlang-skel-separator 2)
+    "init([]) ->" n>
+    "{ok, state_name, #state{}}." n
+    n
+    (erlang-skel-separator 2)
+    "%% Func: StateName/2" n
+    "%% Returns: {next_state, NextStateName, NextStateData}          |" n
+    "%%          {next_state, NextStateName, NextStateData, Timeout} |" n
+    "%%          {stop, Reason, NewStateData}                         " n
+    (erlang-skel-separator 2)
+    "state_name(Event, StateData) ->" n>
+    "{nextstate, state_name, StateData}." n
+    n
+    (erlang-skel-separator 2)
+    "%% Func: StateName/3" n
+    "%% Returns: {next_state, NextStateName, NextStateData}            |" n
+    "%%          {next_state, NextStateName, NextStateData, Timeout}   |" n
+    "%%          {reply, Reply, NextStateName, NextStateData}          |" n
+    "%%          {reply, Reply, NextStateName, NextStateData, Timeout} |" n
+    "%%          {stop, Reason, NewStateData}                          |" n
+    "%%          {stop, Reason, Reply, NewStateData}                    " n
+    (erlang-skel-separator 2)
+    "state_name(Event, From, StateData) ->" n>
+    "Reply = ok," n>
+    "{reply, Reply, state_name, StateData}." n
+    n
+    (erlang-skel-separator 2)
+    "%% Func: handle_event/3" n
+    "%% Returns: {next_state, NextStateName, NextStateData}          |" n
+    "%%          {next_state, NextStateName, NextStateData, Timeout} |" n
+    "%%          {stop, Reason, NewStateData}                         " n
+    (erlang-skel-separator 2)
+    "handle_event(Event, StateName, StateData) ->" n>
+    "{nextstate, StateName, StateData}." n
+    n
+    (erlang-skel-separator 2)
+    "%% Func: handle_sync_event/4" n
+    "%% Returns: {next_state, NextStateName, NextStateData}            |" n
+    "%%          {next_state, NextStateName, NextStateData, Timeout}   |" n
+    "%%          {reply, Reply, NextStateName, NextStateData}          |" n
+    "%%          {reply, Reply, NextStateName, NextStateData, Timeout} |" n
+    "%%          {stop, Reason, NewStateData}                          |" n
+    "%%          {stop, Reason, Reply, NewStateData}                    " n
+    (erlang-skel-separator 2)
+    "handle_sync_event(Event, From, StateName, StateData) ->" n>
+    "Reply = ok," n>
+    "{reply, Reply, StateName, StateData}." n
+    n
+    (erlang-skel-separator 2)
+    "%% Func: handle_info/3" n
+    "%% Returns: {next_state, NextStateName, NextStateData}          |" n
+    "%%          {next_state, NextStateName, NextStateData, Timeout} |" n
+    "%%          {stop, Reason, NewStateData}                         " n
+    (erlang-skel-separator 2)
+    "handle_info(Info, StateName, StateData) ->" n>
+    "{nextstate, StateName, StateData}." n
+    n
+    (erlang-skel-separator 2)
+    "%% Func: terminate/3" n
+    "%% Purpose: Shutdown the fsm" n
+    "%% Returns: any" n
+    (erlang-skel-separator 2)
+    "terminate(Reason, StateName, StatData) ->" n>
+    "ok." n
+    n
+    (erlang-skel-separator)
+    "%%% Internal functions" n
+    (erlang-skel-separator)
+    )
+  "*The template of a gen_fsm.
+Please see the function `tempo-define-template'.")
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Original erlang-add-quotes-if-needed is broken, we install a 
+;; new version.
+;;
+
+(add-hook 'erlang-load-hook 'my-erlang-load-mods)
+
+(defun fixed-erlang-add-quotes-if-needed (str)
+  "Return STR, possibly with quotes."
+  (let ((saved-case-fold-search case-fold-search)
+	(result nil))
+    (setq case-fold-search nil)
+    (setq result (if (string-match (concat "\\`" erlang-atom-regexp "\\'") str)
+		     str
+		   (concat "'" str "'")))
+    (setq case-fold-search saved-case-fold-search)
+    result))
+
+(defun my-erlang-load-mods ()
+ (fset 'erlang-add-quotes-if-needed
+	(symbol-function 'fixed-erlang-add-quotes-if-needed))
+ (appwiz-skel-init))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Additional skeletons which are not shown in the Erlang menu.
+;;
+
+(defvar appwiz-skel
+  '(
+;    ("generic-server-no-api" erlang-skel-generic-server-no-api)
+;    ("generic-server-api"    erlang-skel-generic-server-api)
+;    ("gen-event-no-api"      erlang-skel-gen-event-no-api)
+;    ("gen-event-api"         erlang-skel-gen-event-api)
+;    ("gen-fsm-no-api"	     erlang-skel-gen-fsm-no-api)
+;    ("gen-fsm-api"	     erlang-skel-gen-fsm-api)
+     ("makefile-middle"      erlang-skel-makefile-middle)
+     ("makefile-src"         erlang-skel-makefile-src)))
+
+(defun appwiz-skel-init ()
+  "Generate the skeleton functions."
+  (interactive)
+  (condition-case nil
+      (require 'tempo)
+    (error t))
+  (if (featurep 'tempo)
+      (let ((skel appwiz-skel))
+	(while skel
+	  (funcall (symbol-function 'tempo-define-template)
+		   (concat "erlang-" (nth 0 (car skel)))
+		   ;; The tempo template used contains an `include'
+		   ;; function call only, hence changes to the
+		   ;; variables describing the templates take effect
+		   ;; immdiately.
+		   (list (list 'erlang-skel-include (nth 1 (car skel))))
+		   (nth 0 (car skel)))
+	  (setq skel (cdr skel))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;
+;;;; 
+;;
+;;(defvar erlang-skel-generic-server-no-api
+;;  '((erlang-skel-include erlang-skel-large-header)
+;;    "-behaviour(gen_server)." n
+;;    n
+;;    "%% gen_server callbacks" n
+;;    "-export([init/1, handle_call/3, handle_cast/2, "
+;;    "handle_info/2, terminate/2])." n n
+;;    "-record(state, {})." n 
+;;    n
+;;    (erlang-skel-separator)
+;;    "%%% Callback functions from gen_server" n
+;;    (erlang-skel-separator)
+;;    n
+;;    (erlang-skel-separator 2)
+;;    "%% Func: init/1" n
+;;    "%% Returns: {ok, State}          |" n
+;;    "%%          {ok, State, Timeout} |" n
+;;    "%%          ignore               |" n
+;;    "%%          {stop, Reason}" n
+;;    (erlang-skel-separator 2)
+;;    "init([]) ->" n>
+;;    "{ok, #state{}}." n
+;;    n
+;;    (erlang-skel-separator 2)
+;;    "%% Func: handle_call/3" n
+;;    "%% Returns: {reply, Reply, State}          |" n
+;;    "%%          {reply, Reply, State, Timeout} |" n
+;;    "%%          {noreply, State}               |" n
+;;    "%%          {noreply, State, Timeout}      |" n
+;;    "%%          {stop, Reason, Reply, State}   | (terminate/2 is called)" n
+;;    "%%          {stop, Reason, State}            (terminate/2 is called)" n
+;;    (erlang-skel-separator 2)
+;;    "handle_call(Request, From, State) ->" n>
+;;    "Reply = ok," n>
+;;    "{reply, Reply, State}." n
+;;    n
+;;    (erlang-skel-separator 2)
+;;    "%% Func: handle_cast/2" n
+;;    "%% Returns: {noreply, State}          |" n
+;;    "%%          {noreply, State, Timeout} |" n
+;;    "%%          {stop, Reason, State}            (terminate/2 is called)" n
+;;    (erlang-skel-separator 2)    
+;;    "handle_cast(Msg, State) ->" n>
+;;    "{noreply, State}." n
+;;    n
+;;    (erlang-skel-separator 2)
+;;    "%% Func: handle_info/2" n
+;;    "%% Returns: {noreply, State}          |" n
+;;    "%%          {noreply, State, Timeout} |" n
+;;    "%%          {stop, Reason, State}            (terminate/2 is called)" n
+;;    (erlang-skel-separator 2)
+;;    "handle_info(Info, State) ->" n>
+;;    "{noreply, State}." n
+;;    n
+;;    (erlang-skel-separator 2)
+;;    "%% Func: terminate/2" n
+;;    "%% Purpose: Shutdown the server" n
+;;    "%% Returns: any (ignored by gen_server)" n
+;;    (erlang-skel-separator 2)
+;;    "terminate(Reason, State) ->" n>
+;;    "ok." n
+;;    n
+;;    (erlang-skel-separator)
+;;    "%%% Internal functions" n
+;;    (erlang-skel-separator)
+;;    )
+;;  "*The template of a generic server.
+;;Please see the function `tempo-define-template'.")
+;;
+;;(defvar erlang-skel-generic-server-api
+;;  '((erlang-skel-include erlang-skel-large-header)
+;;    "%% External exports" n
+;;    "-export([start_link/0])." n
+;;    n
+;;    (erlang-skel-separator)
+;;    "%%% API" n
+;;    (erlang-skel-separator)
+;;    "start_link() ->" n>
+;;    "gen_server:start_link({local, " 
+;;    (erlang-add-quotes-if-needed
+;;     (concat (erlang-get-module-from-file-name) "_server")) "}, "
+;;    (erlang-add-quotes-if-needed
+;;     (concat (erlang-get-module-from-file-name) "_server")) ", [], [])." n 
+;;    n
+;;    ))
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;
+;;;;
+;;
+;;(defvar erlang-skel-gen-event-no-api
+;;  '((erlang-skel-include erlang-skel-large-header)
+;;    "-behaviour(gen_event)." n
+;;    n
+;;    "%% gen_event callbacks" n
+;;    "-export([init/1, handle_event/2, handle_call/2, "
+;;    "handle_info/2, terminate/2])." n n
+;;    "-record(state, {})." n 
+;;    n
+;;    (erlang-skel-separator)
+;;    "%%% Callback functions from gen_event" n
+;;    (erlang-skel-separator)
+;;    n
+;;    (erlang-skel-separator 2)
+;;    "%% Func: init/1" n
+;;    "%% Returns: {ok, State}          |" n
+;;    "%%          Other" n
+;;    (erlang-skel-separator 2)
+;;    "init([]) ->" n>
+;;    "{ok, #state{}}." n
+;;    n
+;;    (erlang-skel-separator 2)
+;;    "%% Func: handle_event/2" n
+;;    "%% Returns: {ok, State}                                |" n
+;;    "%%          {swap_handler, Args1, State1, Mod2, Args2} |" n
+;;    "%%          remove_handler                              " n
+;;    (erlang-skel-separator 2)
+;;    "handle_event(Event, State) ->" n>
+;;    "{ok, State}." n
+;;    n
+;;    (erlang-skel-separator 2)
+;;    "%% Func: handle_call/2" n
+;;    "%% Returns: {ok, Reply, State}                                |" n
+;;    "%%          {swap_handler, Reply, Args1, State1, Mod2, Args2} |" n
+;;    "%%          {remove_handler, Reply}                            " n
+;;    (erlang-skel-separator 2)
+;;    "handle_call(Request, State) ->" n>
+;;    "Reply = ok," n>
+;;    "{ok, Reply, State}." n
+;;    n
+;;    (erlang-skel-separator 2)
+;;    "%% Func: handle_info/2" n
+;;    "%% Returns: {ok, State}                                |" n
+;;    "%%          {swap_handler, Args1, State1, Mod2, Args2} |" n
+;;    "%%          remove_handler                              " n
+;;    (erlang-skel-separator 2)
+;;    "handle_info(Info, State) ->" n>
+;;    "{ok, State}." n
+;;    n
+;;    (erlang-skel-separator 2)
+;;    "%% Func: terminate/2" n
+;;    "%% Purpose: Shutdown the server" n
+;;    "%% Returns: any" n
+;;    (erlang-skel-separator 2)
+;;    "terminate(Reason, State) ->" n>
+;;    "ok." n
+;;    n
+;;    (erlang-skel-separator)
+;;    "%%% Internal functions" n
+;;    (erlang-skel-separator)
+;;    )
+;;  "*The template of a gen_event.
+;;Please see the function `tempo-define-template'.")
+;;
+;;(defvar erlang-skel-gen-event-api
+;;  '((erlang-skel-include erlang-skel-large-header)
+;;    "%% External exports" n
+;;    "-export([start_link/0, add_handler/0])." n
+;;    n
+;;    (erlang-skel-separator)
+;;    "%%% API" n
+;;    (erlang-skel-separator)
+;;    "start_link() ->" n>
+;;    "gen_event:start_link({local, " 
+;;    (erlang-add-quotes-if-needed
+;;     (concat (erlang-get-module-from-file-name) "_event")) "}). " n
+;;    n
+;;    "add_handler() ->" n>
+;;    "gen_event:add_handler("
+;;    (erlang-add-quotes-if-needed
+;;     (concat (erlang-get-module-from-file-name) "_event")) ", "
+;;    (erlang-add-quotes-if-needed
+;;     (concat (erlang-get-module-from-file-name) "_event")) ", [])." n 
+;;    n))
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;
+;;;;
+;;
+;;(defvar erlang-skel-gen-fsm
+;;  '((erlang-skel-include erlang-skel-large-header)
+;;    "-behaviour(gen_fsm)." n
+;;    n
+;;    "%% gen_fsm callbacks" n
+;;    "-export([init/1, state_name/2, state_name/3, handle_event/3," n>
+;;    "handle_sync_event/4, handle_info/3, terminate/3])." n n
+;;    "-record(state, {})." n 
+;;    n
+;;    (erlang-skel-separator)
+;;    "%%% Callback functions from gen_fsm" n
+;;    (erlang-skel-separator)
+;;    n
+;;    (erlang-skel-separator 2)
+;;    "%% Func: init/1" n
+;;    "%% Returns: {ok, StateName, StateData}          |" n
+;;    "%%          {ok, StateName, StateData, Timeout} |" n
+;;    "%%          ignore                              |" n
+;;    "%%          {stop, StopReason}                   " n
+;;    (erlang-skel-separator 2)
+;;    "init([]) ->" n>
+;;    "{ok, state_name, #state{}}." n
+;;    n
+;;    (erlang-skel-separator 2)
+;;    "%% Func: StateName/2" n
+;;    "%% Returns: {next_state, NextStateName, NextStateData}          |" n
+;;    "%%          {next_state, NextStateName, NextStateData, Timeout} |" n
+;;    "%%          {stop, Reason, NewStateData}                         " n
+;;    (erlang-skel-separator 2)
+;;    "state_name(Event, StateData) ->" n>
+;;    "{nextstate, state_name, StateData}." n
+;;    n
+;;    (erlang-skel-separator 2)
+;;    "%% Func: StateName/3" n
+;;    "%% Returns: {next_state, NextStateName, NextStateData}            |" n
+;;    "%%          {next_state, NextStateName, NextStateData, Timeout}   |" n
+;;    "%%          {reply, Reply, NextStateName, NextStateData}          |" n
+;;    "%%          {reply, Reply, NextStateName, NextStateData, Timeout} |" n
+;;    "%%          {stop, Reason, NewStateData}                          |" n
+;;    "%%          {stop, Reason, Reply, NewStateData}                    " n
+;;    (erlang-skel-separator 2)
+;;    "state_name(Event, From, StateData) ->" n>
+;;    "Reply = ok," n>
+;;    "{reply, Reply, state_name, StateData}." n
+;;    n
+;;    (erlang-skel-separator 2)
+;;    "%% Func: handle_event/3" n
+;;    "%% Returns: {next_state, NextStateName, NextStateData}          |" n
+;;    "%%          {next_state, NextStateName, NextStateData, Timeout} |" n
+;;    "%%          {stop, Reason, NewStateData}                         " n
+;;    (erlang-skel-separator 2)
+;;    "handle_event(Event, StateName, StateData) ->" n>
+;;    "{nextstate, StateName, StateData}." n
+;;    n
+;;    (erlang-skel-separator 2)
+;;    "%% Func: handle_sync_event/4" n
+;;    "%% Returns: {next_state, NextStateName, NextStateData}            |" n
+;;    "%%          {next_state, NextStateName, NextStateData, Timeout}   |" n
+;;    "%%          {reply, Reply, NextStateName, NextStateData}          |" n
+;;    "%%          {reply, Reply, NextStateName, NextStateData, Timeout} |" n
+;;    "%%          {stop, Reason, NewStateData}                          |" n
+;;    "%%          {stop, Reason, Reply, NewStateData}                    " n
+;;    (erlang-skel-separator 2)
+;;    "handle_sync_event(Event, From, StateName, StateData) ->" n>
+;;    "Reply = ok," n>
+;;    "{reply, Reply, StateName, StateData}." n
+;;    n
+;;    (erlang-skel-separator 2)
+;;    "%% Func: handle_info/3" n
+;;    "%% Returns: {next_state, NextStateName, NextStateData}          |" n
+;;    "%%          {next_state, NextStateName, NextStateData, Timeout} |" n
+;;    "%%          {stop, Reason, NewStateData}                         " n
+;;    (erlang-skel-separator 2)
+;;    "handle_info(Info, StateName, StateData) ->" n>
+;;    "{nextstate, StateName, StateData}." n
+;;    n
+;;    (erlang-skel-separator 2)
+;;    "%% Func: terminate/3" n
+;;    "%% Purpose: Shutdown the fsm" n
+;;    "%% Returns: any" n
+;;    (erlang-skel-separator 2)
+;;    "terminate(Reason, StateName, StatData) ->" n>
+;;    "ok." n
+;;    n
+;;    (erlang-skel-separator)
+;;    "%%% Internal functions" n
+;;    (erlang-skel-separator)
+;;    )
+;;  "*The template of a gen_fsm.
+;;Please see the function `tempo-define-template'.")
+;;
+;;(defvar erlang-skel-gen-fsm-no-api
+;;  '((erlang-skel-include erlang-skel-large-header)
+;;        "%% External exports" n
+;;    "-export([start_link/0])." n
+;;    n
+;;    (erlang-skel-separator)
+;;    "%%% API" n
+;;    (erlang-skel-separator)
+;;    "start_link() ->" n>
+;;    "gen_fsm:start_link({local, " 
+;;    (erlang-add-quotes-if-needed
+;;     (concat (erlang-get-module-from-file-name) "_fsm")) "}, "
+;;    (erlang-add-quotes-if-needed
+;;     (concat (erlang-get-module-from-file-name) "_fsm")) ", [], [])." n 
+;;    n
+;;    ))
+;;
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 
+;; requires that the variables appwiz-erlang-modulename and
+;; appwiz-erlang-ext are defined.
+;;
+
+(defvar erlang-skel-makefile-src
+  '((erlang-skel-include erlang-skel-nomodule-header)
+    "MAKE = make" n
+    n
+    "ERL = erlc" n
+    n
+    "EBIN = ../ebin" n
+    n
+    (erlang-skel-makefile-separator)
+    n
+    (upcase appwiz-erlang-modulename) "_HEADER_FILES = "
+    appwiz-erlang-modulename "_sup.hrl" n
+    n
+    (upcase appwiz-erlang-modulename) "_SOURCE_FILES = \\" n
+    "	" appwiz-erlang-modulename ".erl" " "
+    appwiz-erlang-modulename "_sup.erl \\" n
+    "	" appwiz-erlang-modulename "_app.erl" " "
+    appwiz-erlang-modulename appwiz-erlang-ext ".erl" n
+    n
+    (upcase appwiz-erlang-modulename) "_OBJECT_FILES = $("
+    (upcase appwiz-erlang-modulename) "_SOURCE_FILES:.erl=.jam)" n
+    n
+    n
+    (erlang-skel-makefile-separator)
+    "#" n
+    "# Transformations " n
+    "#" n
+    n
+    ".erl.jam:" n
+    "	$(ERL) $<" n
+    n
+    (erlang-skel-makefile-separator) n
+    n
+    n
+    "def : "
+    appwiz-erlang-modulename n
+    n
+    appwiz-erlang-modulename ": $("
+    (upcase appwiz-erlang-modulename) "_OBJECT_FILES)" n
+    "	cp $(" (upcase appwiz-erlang-modulename) "_OBJECT_FILES) "
+    "$(EBIN)" n
+    n
+    "clean :" n
+    "	/bin/rm -f $(" (upcase appwiz-erlang-modulename)
+    "_OBJECT_FILES)" n
+    n
+    "$(" (upcase appwiz-erlang-modulename) "_OBJECT_FILES): $("
+    (upcase appwiz-erlang-modulename) "_HEADER_FILES)" n
+    n
+    ".SUFFIXES : .erl .jam" n
+    n
+    ))
+
+(defvar erlang-skel-makefile-middle
+  '((erlang-skel-include erlang-skel-nomodule-header)
+    "MAKE = make" n
+    n
+    (erlang-skel-makefile-separator)
+    n
+    "def:" n
+    "	(cd src ; $(MAKE))" n
+    n
+    "clean:" n
+    "	(cd src ; $(MAKE) clean)" n
+    n
+    ))
+    
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun erlang-skel-makefile-separator ()
+  "Return a comment separator."
+  (concat (make-string 70 ?\#) "\n"))