home *** CD-ROM | disk | FTP | other *** search
/ Programmer's ROM - The Computer Language Library / programmersrom.iso / ada / extrnl / adamode.old < prev    next >
Encoding:
Text File  |  1988-05-03  |  18.7 KB  |  626 lines
  1. ::::::::::
  2. adaemacs.doc
  3. ::::::::::
  4. The files MICRO:<ADA.EXTERNAL-TOOLS>ADA-EMACS.PART1, ADA-EMACS.PART2
  5. contain this tool.
  6.  
  7. Date: Monday, 29 April 1985  07:48-MDT
  8. From: ihnp4!siemens!rosen at Ucb-Vax.ARPA
  9. Re:   Ada Mode for Emacs Editor
  10.  
  11.     I have available an Ada mode for use with the Emacs editor.  It is
  12. written in Mlisp, so I can only vouch for the Gosling version.  If anybody
  13. is interested in it let me know and I will send it along to them.  If there
  14. is enough interest, I will just post it to the net.  It is intended for use
  15. when editing Ada code and it has various features which help make writing
  16. Ada programs easier.
  17.  
  18.  
  19. Steve Rosen
  20. Siemens Research and Technology Laboratories
  21. Princeton, NJ
  22.  
  23. USENET: {ihnp4|princeton|adrvax}!siemens!rosen
  24. ARPA:   princeton!siemens!rosen@TOPAZ
  25.  
  26.  
  27. ::::::::::
  28. adaemacs.p1
  29. ::::::::::
  30.  
  31.  
  32. ------------------------------------------------------------------------------
  33.  
  34.                         Ada Mode for Gosling Emacs
  35.  
  36.                              Steven M. Rosen
  37.  
  38.                  Siemens Corporate Research and Support, Inc.
  39.                     Research and Technology Laboratories
  40.                             Princeton, NJ 08540
  41.                               (609) 734-6538
  42.  
  43.                                rosen@siemens
  44.  
  45. ------------------------------------------------------------------------------
  46.  
  47. The Ada mode Mlisp code defines a special mode for the Gosling version of
  48. the Emacs editor.  How it works with other versions of Emacs are unclear,
  49. since it was written for and tested with the Gosling version.  The Ada mode
  50. is intended for use when editing Ada code and it is case insensitive when 
  51. dealing with reserved Ada words.
  52.  
  53. Place the file 'ada.ml' in your local Emacs Mlisp code library directory.
  54. This is usually something like '/usr/lib/emacs/maclib'.
  55.  
  56. To have the editor invoke the Ada mode when editing Ada source code, place
  57. the following lines in your '.emacs_pro' profile script.
  58.  
  59.         (autoload "ada-mode" "ada.ml")
  60.         (auto-execute "ada-mode" "*.ada")
  61.  
  62. You can change the second line to have the Ada mode loaded when you are
  63. editing files with extensions other than ".ada"
  64.  
  65. Ada mode automatically performs indenting while you are editing Ada code.
  66. Is assumes that you are using a style that is similar to that used in the
  67. Ada LRM (Language Reference Manual).  It automatically indents and dedents
  68. blocks of code by examing the syntax of the statements that you are writing.
  69. Using very unusually or ad hoc coding styles will not produce results that
  70. are anything spectacular.
  71.  
  72. Using this editing mode takes a bit of getting used to, but it shouldn't take
  73. long to become comfortable with it.  It is far from perfect, but I felt a 
  74. strong need to write it because the power of Emacs is too good to put to
  75. waste and I was writting too much Ada code to be without it.
  76. For those of you who attempt to make it run with other versions of Emacs
  77. please let me know since I know nothing of how other versions differ from the
  78. Gosling version.  If you have any questions or find very strange bugs, send
  79. them to the above address and I will attempt to fix them.  The comment mode
  80. was particularly hard to implement, but it does work fairly well when
  81. writting most comments.  I can't promise that writting comments won't do
  82. strange stuff every so often.  If you fix a bug or make an enhancement send
  83. it to me so I can enjoy it as well.  Have fun!
  84.  
  85. ------------------------------------------------------------------------------
  86.  
  87. Variables and Functions
  88.         
  89.         indent-change    The number of spaces to use when indenting
  90.                          statements.  This number can be changed to 4 or
  91.                          whatever you like.  The default is 2.
  92.  
  93.         ^X->             Indents a region of code from 'dot' to 'mark' by
  94.                          the value 'indent-change'.
  95.  
  96.         ^X-<             Dedents a region of code from 'dot' to 'mark' by
  97.                          the value 'indent-change'.
  98.  
  99.         <ESC>-<TAB>      Tab over to the column of the previous statement.
  100.                          If at the beginning of a line, this will move the
  101.                          cursor over to the same column as the most recent
  102.                          line of code.  If the current column is greater
  103.                          that the column of the most recent line of code,
  104.                          then a <TAB> character is inserted.
  105.  
  106.         <TAB>            Same as above, but you can disable the key binding
  107.                          if hitting a <TAB> does things that you don't like.
  108.  
  109.         <ESC>-<CR>       If at the end of a line. inserts a <CR> and dedents
  110.                          by 'indent-change'.  If on a blank like, it just
  111.                          dedents by 'indent-change'.  This is used, for
  112.                          example, when you wish to dedent a block of code,
  113.                          and insert an 'end' statement such as in a 'for'
  114.                          loop;
  115.  
  116.                          Example:
  117.  
  118.                                   for i in 1 .. 100 loop
  119.                                     j := x(1);
  120.                                     z := sqrt(j); -- Type an <ESC>-<CR> here
  121.                                   end loop;
  122.  
  123.                          The <ESC>-<CR> is a signal that you want to close off
  124.                          a block of code with and 'end' statement.  If you
  125.                          have forgotten to type the <ESC>-<CR> sequence and
  126.                          you are sitting on a blank line type it anyway and
  127.                          you will be repositioned automatically!
  128.  
  129.  
  130.         '--'             Typing these two characters will automatically put
  131.                          you into a special comment editing mode.  This mode
  132.                          will wrap lines automatically when you are typing
  133.                          long comments.  The characters '--' are
  134.                          automatically created and inserted so the user does
  135.                          not have to type them when writing a comment that
  136.                          carries over to several lines.  Typing a <CR> on
  137.                          a blank line (after a '--' has been automatically
  138.                          inserted), will leave the comment mode and return
  139.                          you to editing statement editing by repositioning
  140.                          the cursor in the correct place.
  141.  
  142. ------------------------------------------------------------------------------
  143.  
  144.  
  145. ::::::::::
  146. adaemacs.p2
  147. ::::::::::
  148.  
  149.  
  150. ; ----------------------------------------------------------------------------
  151. ; ada.ml - Ada mode for Emacs
  152. ; ----------------------------------------------------------------------------
  153. ;  
  154. ;                         Ada Mode for Gosling Emacs
  155. ;  
  156. ;                              Steven M. Rosen
  157. ;  
  158. ;                  Siemens Corporate Research and Support, Inc.
  159. ;                     Research and Technology Laboratories
  160. ;                             Princeton, NJ 08540
  161. ;                                (609) 734-6538
  162. ;  
  163. ;                                 rosen@siemens
  164. ; 
  165. ; ----------------------------------------------------------------------------
  166. ; 
  167. ;     This code is public domain and may be used or modified at your site
  168. ;     in any fashion that you choose.  No support or capabilities are
  169. ;     implied or guaranteed by the release of this code.  This disclaimer
  170. ;    must be maintained in conjunction with the code.
  171. ; 
  172. ; ----------------------------------------------------------------------------
  173. ;
  174. ; $Header: ada.ml,v 4.1 85/04/15 08:33:06 rosen Exp $
  175. ; 
  176. ; Created 12-18-84
  177. ; Updated 04-15-85
  178. ; 
  179. ; Bindings:
  180. ; 
  181. ;     indent-change = size of indentation (default to 2)
  182. ; 
  183. ;     Indent from (dot) to (mark)              ^X->
  184. ;     De-dent from (dot) to (mark)              ^X-<
  185. ;     Tab over to indent of most recent line of code      <TAB>,<ESC><TAB>
  186. ;     Decrease indent level and start newline          <ESC>-<CR>
  187. ;     Enter Ada comment mode                  "--"
  188. ; 
  189. ; Features:
  190. ; 
  191. ;   o    Automatically performs indentation while editing Ada code.
  192. ; 
  193. ;   o    Automatically performs justification of Ada comments which
  194. ;     begin on a blank line.
  195. ; 
  196. ;   o    Automatically matches parentheses.
  197. ; 
  198.  
  199.  
  200. (defun
  201.     (ada-mode
  202.     (declare-buffer-specific in-comment-edit)
  203.     (setq-default indent-change 2)
  204.     (setq tab-size 8)
  205.     (setq in-comment-edit 0)
  206.     (setq mode-string "Ada")
  207.     (use-syntax-table "Ada")
  208.     (setq abbrev-mode 1)
  209.     (local-bind-to-key "begin-ada-comment" "-")
  210.     (local-bind-to-key "indent-region" "\^X>")
  211.     (local-bind-to-key "dedent-region" "\^X<")
  212.     (local-bind-to-key "tab-ada" "\t")
  213.     (local-bind-to-key "tab-ada" "\e\t")
  214.     (local-bind-to-key "indent-ada" "\^M")
  215.     (local-bind-to-key "de-dent-ada" "\e\^M")
  216.     (local-bind-to-key "show-matching-paren" ")")
  217. ; 
  218. ; The following two lines can be include to suit local naming 
  219. ; conventions:
  220. ; 
  221. ;    (modify-syntax-entry "w    _")
  222. ;    (modify-syntax-entry "w    .")
  223. ; 
  224. ;
  225.     (modify-syntax-entry "()   (")
  226.     (modify-syntax-entry ")(   )")
  227.     (modify-syntax-entry "\"    \"")
  228.     (modify-syntax-entry "  { --")
  229.     (modify-syntax-entry "   } \n")
  230.     (error-occurred (ada-mode-hook))
  231.     (novalue)
  232.     )
  233. )    
  234.  
  235. (defun 
  236.     (cond n running
  237.       (setq n 1)
  238.       (setq running 1)
  239.       (while (& running (< n (nargs)))
  240.          (if (arg n)
  241.              (setq running 0)
  242.              (setq n (+ n 2))))
  243.       (arg (+ n 1))))
  244.     
  245. (defun 
  246.     (show-matching-paren
  247.     (insert-character (last-key-struck))
  248.     (save-excursion 
  249.         (backward-paren)
  250.         (if (dot-is-visible)
  251.         (sit-for 5)
  252.         (progn 
  253.                (beginning-of-line)
  254.                (set-mark)
  255.                (end-of-line)
  256.                (message (region-to-string)))))))
  257.     
  258. (defun 
  259.     (leave-and-show
  260.     (setq abbrev-mode 1)
  261.     (show-matching-paren)))
  262.     
  263. (defun 
  264.     (change-indentation colno    ; indent by arg for region
  265.     (save-excursion 
  266.         (if (< (mark) (dot))
  267.         (progn 
  268.                (end-of-line)
  269.                (exchange-dot-and-mark)
  270.                (beginning-of-line))
  271.         (progn 
  272.                (beginning-of-line)
  273.                (exchange-dot-and-mark)
  274.                (end-of-line)))
  275.         (narrow-region)
  276.         (end-of-file)
  277.         (beginning-of-line)
  278.         (setq colno (+ (current-indent) (arg 1)))
  279.         (delete-white-space)
  280.         (if (> colno 1)
  281.         (to-col colno))
  282.         (beginning-of-line)
  283.         (while (! (bobp))
  284.            (previous-line)
  285.            (setq colno (+ (current-indent) (arg 1)))
  286.            (delete-white-space)
  287.            (if (> colno 1)
  288.                (to-col colno))
  289.            (beginning-of-line))
  290.         (widen-region))))
  291.     
  292. (defun 
  293.     (dedent-region         ; dedents region
  294.     (change-indentation (- 0 indent-change))))
  295.     
  296. (defun 
  297.     (indent-region colno    ; indents region
  298.     (change-indentation indent-change)))
  299.     
  300.     
  301. (defun 
  302.     (tab-ada dotab colno
  303.     (if 
  304.         (& (eobp) (eolp))
  305.         (progn 
  306.            (insert-character '\n')
  307.            (backward-character))
  308.     )
  309.     (if 
  310.         (| (& (bolp) (looking-at "[ \t]*\n"))
  311.            (< (current-column) (current-indent)))
  312.         (progn 
  313.            (save-excursion 
  314.                (while 
  315.                   (& (| (looking-at "[ \t]*\n") 
  316.                     (looking-at "[ \t]*--"))
  317.                  (! (bobp)))
  318.                   (progn 
  319.                      (previous-line)
  320.                      (beginning-of-line)))
  321.                (setq colno (current-indent)))
  322.            (delete-white-space)
  323.            (to-col colno))
  324.         1
  325.         (insert-character '\t'))))
  326.     
  327. (defun 
  328.     (de-dent-ada colno
  329.     (setq colno (- (current-indent) indent-change))
  330.     (beginning-of-line)
  331.     (if 
  332.         (! (looking-at "[ \t]*\n"))
  333.             (progn 
  334.                 (end-of-line)
  335.                 (newline)))
  336.     (delete-white-space)
  337.     (to-col colno)))
  338.  
  339. (defun 
  340.     (indent-ada colno
  341.     (cond
  342.          (bolp)
  343.          (newline)
  344.          (! (eolp))
  345.          (newline-and-indent)
  346.          1
  347.          (progn
  348.            (save-excursion
  349.                (end-of-line)
  350.                (if (eobp)
  351.                (newline)))
  352.            (setq colno (current-indent))
  353.            (beginning-of-line)
  354.            (setq case-fold-search 1)
  355.            (cond
  356.             (& (= in-comment-edit 1)
  357.                (looking-at "[ \t]*-- \n"))
  358.             (progn 
  359.                    (setq in-comment-edit 0)
  360.                    (beginning-of-line)
  361.                    (kill-to-end-of-line)
  362.                    (kill-to-end-of-line)
  363.                    (if 
  364.                    (looking-at "[ \t]*\n")
  365.                    (tab-ada)
  366.                    1
  367.                    (beginning-of-line))
  368.                    (setq right-margin 1000)
  369.                    (setq left-margin 1)
  370.                    (setq prefix-string "")
  371.                    (local-bind-to-key "begin-ada-comment" "-")
  372.                    (local-bind-to-key "tab-ada" "\t")
  373.                    (message "Finished editing ada comment"))
  374.             (& (= in-comment-edit 1)
  375.                (! (looking-at "[ \t]*--[ \t]*..")))
  376.             (progn 
  377.                    (end-of-line)
  378.                    (newline)
  379.                    (to-col comment-column)
  380.                    (insert-string "-- "))
  381.             (& (= in-comment-edit 1)
  382.                (looking-at "[ \t]*--[ \t]*.."))
  383.             (progn 
  384.                    (end-of-line)
  385.                    (newline-and-indent)
  386.                    (insert-string "-- "))
  387.             (looking-at "[ \t]*--.*\n")
  388.             (progn 
  389.                    (end-of-line)
  390.                    (newline)
  391.                    (tab-ada))
  392.             (looking-at "[ \t]*begin\\b")
  393.             (progn 
  394.                    (end-of-line)
  395.                    (newline)
  396.                    (to-col (+ colno indent-change)))
  397.             (looking-at "[ \t]*end\\b")
  398.             (progn 
  399.                    (end-of-line)
  400.                    (newline)
  401.                    (to-col (- colno indent-change)))
  402.             (looking-at "[ \t]*when\\b")
  403.             (progn 
  404.                    (end-of-line)
  405.                    (newline)
  406.                    (to-col (+ colno indent-change)))
  407.             (looking-at "[ \t]*generic\\b")
  408.             (progn 
  409.                    (end-of-line)
  410.                    (newline)
  411.                    (to-col (+ colno indent-change)))
  412.             (looking-at "[ \t]*declare\\b")
  413.             (progn 
  414.                    (end-of-line)
  415.                    (newline)
  416.                    (to-col (+ colno indent-change)))
  417.             (looking-at "[ \t]*loop\\b")
  418.             (progn 
  419.                    (end-of-line)
  420.                    (newline)
  421.                    (to-col (+ colno indent-change)))
  422.             (looking-at "[ \t]*if\\b")
  423.             (progn 
  424.                    (end-of-line)
  425.                    (newline)
  426.                    (to-col (+ colno indent-change)))
  427.             (looking-at "[ \t]*elsif\\b")
  428.             (progn 
  429.                    (end-of-line)
  430.                    (newline)
  431.                    (to-col (+ colno indent-change)))
  432.             (looking-at "[ \t]*else\\b")
  433.             (progn 
  434.                    (end-of-line)
  435.                    (newline)
  436.                    (to-col (+ colno indent-change)))
  437.             (looking-at "[ \t]*while\\b")
  438.             (progn 
  439.                    (end-of-line)
  440.                    (newline)
  441.                    (to-col (+ colno indent-change)))
  442.             (looking-at "[ \t]*case\\b")
  443.             (progn 
  444.                    (end-of-line)
  445.                    (newline)
  446.                    (to-col (+ colno indent-change)))
  447.             (looking-at "[ \t]*for\\b")
  448.             (progn 
  449.                    (end-of-line)
  450.                    (if (= (preceding-char) ';')
  451.                    (newline-and-indent)
  452.                    (progn 
  453.                       (newline)
  454.                       (to-col (+ colno indent-change)))))
  455.             (looking-at "[ \t]*loop\\b")
  456.             (progn 
  457.                    (end-of-line)
  458.                    (newline)
  459.                    (to-col (+ colno indent-change)))
  460.             (looking-at "[ \t]*or\\b")
  461.             (progn 
  462.                    (end-of-line)
  463.                    (newline)
  464.                    (to-col (+ colno indent-change)))
  465.             (looking-at "[ \t]*exception\\b")
  466.             (progn 
  467.                    (end-of-line)
  468.                    (newline)
  469.                    (to-col (+ colno indent-change)))
  470.             (looking-at "[ \t]*record\\b")
  471.             (progn 
  472.                    (end-of-line)
  473.                    (newline)
  474.                    (to-col (+ colno indent-change)))
  475.             (looking-at "[ \t]*private\\b")
  476.             (progn 
  477.                    (end-of-line)
  478.                    (newline)
  479.                    (to-col (+ colno indent-change)))
  480.             (| (looking-at "[ \t]*type\\b")
  481.                (looking-at "[ \t]*subtype\\b"))
  482.             (progn 
  483.                    (end-of-line)
  484.                    (backward-word)
  485.                    (if 
  486.                    (looking-at "record\\b")
  487.                    (progn 
  488.                       (setq colno (current-column))
  489.                       (end-of-line)
  490.                       (newline)
  491.                       (to-col (+ colno indent-change)))
  492.                    (looking-at "is\\b")
  493.                    (progn 
  494.                       (end-of-line)
  495.                       (newline)
  496.                       (to-col (+ colno indent-change)))
  497.                    1
  498.                    (progn 
  499.                       (end-of-line)
  500.                       (newline-and-indent))))
  501.             (looking-at "[ \t]*select\\b")
  502.             (progn 
  503.                    (end-of-line)
  504.                    (newline)
  505.                    (to-col (+ colno indent-change)))
  506.             (looking-at "[ \t]*accept\\b")
  507.             (progn 
  508.                    (end-of-line)
  509.                    (backward-word)
  510.                    (if (looking-at "do\\b")
  511.                    (progn 
  512.                       (end-of-line)
  513.                       (newline)
  514.                       (to-col (+ colno indent-change)))
  515.                    (progn 
  516.                       (end-of-line)
  517.                       (newline-and-indent))))
  518.             (looking-at "[ \t]*task\\b")
  519.             (progn 
  520.                    (end-of-line)
  521.                    (backward-word)
  522.                    (if (looking-at "is\\b")
  523.                    (progn 
  524.                       (end-of-line)
  525.                       (newline)
  526.                       (to-col (+ colno indent-change)))
  527.                    (progn 
  528.                       (end-of-line)
  529.                       (newline-and-indent))))
  530.             (| (looking-at "[ \t]*procedure\\b")
  531.                (looking-at "[ \t]*function\\b"))
  532.             (progn 
  533.                    (end-of-line)
  534.                    (backward-word)
  535.                    (if (looking-at "is\\b")
  536.                    (progn 
  537.                       (end-of-line)
  538.                       (newline)
  539.                       (to-col (+ colno indent-change)))
  540.                    (progn 
  541.                       (end-of-line)
  542.                       (newline-and-indent))))
  543.             (looking-at "[ \t]*package\\b")
  544.             (progn 
  545.                    (end-of-line)
  546.                    (backward-word)
  547.                    (if (looking-at "is\\b")
  548.                    (progn 
  549.                       (end-of-line)
  550.                       (newline)
  551.                       (to-col (+ colno indent-change)))
  552.                    (progn 
  553.                       (end-of-line)
  554.                       (newline-and-indent))))
  555.             (|  (looking-at "[ \t]*.*:[^=].*[^;]\n")
  556.                 (looking-at "[ \t]*.*:[ \t]*\n"))
  557.             (progn 
  558.                    (end-of-line)
  559.                    (newline)
  560.                    (to-col (+ colno indent-change)))
  561.             (looking-at "[ \t]*<<.*>>")
  562.             (progn 
  563.                    (end-of-line)
  564.                    (newline)
  565.                    (to-col (+ colno indent-change)))
  566.             1
  567.             (progn
  568.                   (setq colno (current-indent))
  569.                   (if (looking-at "[ \t][ \t]*\n")
  570.                   (kill-to-end-of-line))
  571.                   (end-of-line)
  572.                   (newline)
  573.                   (to-col colno)))
  574.            (setq case-fold-search 0)))))
  575.  
  576. (defun
  577.     (begin-ada-comment c
  578.     (insert-character (last-key-struck))
  579.     (remove-local-binding "-")
  580.     (remove-local-binding "\t")
  581.     (setq c (get-tty-character))
  582.     (insert-character c)
  583.     (if 
  584.         (&
  585.           (= c 45)
  586.           (looking-at "[ \t]*\n"))
  587.         (progn 
  588.            (setq in-comment-edit 1)
  589.            (setq comment-column (- (current-column) 2))
  590.            (move-to-comment-column)
  591.            (setq left-margin comment-column)
  592.            (setq right-margin 76)
  593.            (setq prefix-string "-- ")
  594.            (cond 
  595.              (looking-at "[ \t]*--")
  596.              (progn 
  597.                 (end-of-line)
  598.                 (newline)
  599.                 (to-col comment-column)
  600.                 (insert-string "-- "))
  601.              1
  602.              (end-of-line))
  603.            (message "Editing ada comment")
  604.         )
  605.         1
  606.         (progn 
  607.            (local-bind-to-key "begin-ada-comment" "-")
  608.            (local-bind-to-key "tab-ada" "\t")
  609.         ))
  610.     )
  611. )
  612.  
  613. (defun
  614.     (end-ada-comment
  615.         (setq in-comment-edit 0)
  616.         (setq right-margin 1000)
  617.         (if (!= (preceding-char) ' ') (insert-string " "))
  618.         (to-col comment-column)
  619.         (insert-string "--")
  620.         (newline)
  621.         (local-bind-to-key "tab-ada" "\t")
  622.         (message "Finished editing ada comment")
  623.     )
  624. )
  625. ; ----------------------------------------------------------------------------
  626.