1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
|
;;; asm-mode.el --- mode for editing assembler code -*- lexical-binding: t; -*-
;; Copyright (C) 1991, 2001-2021 Free Software Foundation, Inc.
;; Author: Eric S. Raymond <esr@snark.thyrsus.com>
;; Maintainer: emacs-devel@gnu.org
;; Keywords: languages
;; This file is part of GNU Emacs.
;; GNU Emacs is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
;;; Commentary:
;; This mode was written by Eric S. Raymond <esr@snark.thyrsus.com>,
;; inspired by an earlier asm-mode by Martin Neitzel.
;; This major mode is based on prog mode. It defines a private abbrev table
;; that can be used to save abbrevs for assembler mnemonics. It binds just
;; five keys:
;;
;; TAB tab to next tab stop
;; : outdent preceding label, tab to tab stop
;; comment char place or move comment
;; asm-comment-char specifies which character this is;
;; you can use a different character in different
;; Asm mode buffers.
;; C-j, C-m newline and tab to tab stop
;;
;; Code is indented to the first tab stop level.
;; This mode runs two hooks:
;; 1) An asm-mode-set-comment-hook before the part of the initialization
;; depending on asm-comment-char, and
;; 2) an asm-mode-hook at the end of initialization.
;;; Code:
(defgroup asm nil
"Mode for editing assembler code."
:link '(custom-group-link :tag "Font Lock Faces group" font-lock-faces)
:group 'languages)
(defcustom asm-comment-char ?\;
"The `comment-start' character assumed by Asm mode."
:type 'character)
(defvar asm-mode-syntax-table
(let ((st (make-syntax-table)))
(modify-syntax-entry ?\n "> b" st)
(modify-syntax-entry ?/ ". 124b" st)
(modify-syntax-entry ?* ". 23" st)
st)
"Syntax table used while in Asm mode.")
(defvar asm-mode-abbrev-table nil
"Abbrev table used while in Asm mode.")
(define-abbrev-table 'asm-mode-abbrev-table ())
(defvar asm-mode-map
(let ((map (make-sparse-keymap)))
;; Note that the comment character isn't set up until asm-mode is called.
(define-key map ":" 'asm-colon)
(define-key map "\C-c;" 'comment-region)
map)
"Keymap for Asm mode.")
(easy-menu-define asm-mode-menu asm-mode-map
"Menu for Asm mode."
'("Asm"
["Insert Colon" asm-colon
:help "Insert a colon; if it follows a label, delete the label's indentation"]
["Insert Newline and Indent" newline-and-indent
:help "Insert a newline, then indent according to major mode"]
["Comment Region" comment-region
:help "Comment or uncomment each line in the region"]))
(defconst asm-font-lock-keywords
(append
'(("^\\(\\(\\sw\\|\\s_\\)+\\)\\>:?[ \t]*\\(\\sw+\\(\\.\\sw+\\)*\\)?"
(1 font-lock-function-name-face) (3 font-lock-keyword-face nil t))
;; label started from ".".
("^\\(\\.\\(\\sw\\|\\s_\\)+\\)\\>:"
1 font-lock-function-name-face)
("^\\((\\sw+)\\)?\\s +\\(\\(\\.?\\sw\\|\\s_\\)+\\(\\.\\sw+\\)*\\)"
2 font-lock-keyword-face)
;; directive started from ".".
("^\\(\\.\\(\\sw\\|\\s_\\)+\\)\\>[^:]?"
1 font-lock-keyword-face)
;; %register
("%\\sw+" . font-lock-variable-name-face))
cpp-font-lock-keywords)
"Additional expressions to highlight in Assembler mode.")
;;;###autoload
(define-derived-mode asm-mode prog-mode "Assembler"
"Major mode for editing typical assembler code.
Features a private abbrev table and the following bindings:
\\[asm-colon]\toutdent a preceding label, tab to next tab stop.
\\[tab-to-tab-stop]\ttab to next tab stop.
\\[newline-and-indent]\tnewline, then tab to next tab stop.
\\[asm-comment]\tsmart placement of assembler comments.
The character used for making comments is set by the variable
`asm-comment-char' (which defaults to `?\\;').
Alternatively, you may set this variable in `asm-mode-set-comment-hook',
which is called near the beginning of mode initialization.
Turning on Asm mode runs the hook `asm-mode-hook' at the end of initialization.
Special commands:
\\{asm-mode-map}"
(setq local-abbrev-table asm-mode-abbrev-table)
(setq-local font-lock-defaults '(asm-font-lock-keywords))
(setq-local indent-line-function #'asm-indent-line)
;; Stay closer to the old TAB behavior (was tab-to-tab-stop).
(setq-local tab-always-indent nil)
(run-hooks 'asm-mode-set-comment-hook)
;; Make our own local child of asm-mode-map
;; so we can define our own comment character.
(use-local-map (nconc (make-sparse-keymap) asm-mode-map))
(local-set-key (vector asm-comment-char) #'asm-comment)
(set-syntax-table (make-syntax-table asm-mode-syntax-table))
(modify-syntax-entry asm-comment-char "< b")
(setq-local comment-start (string asm-comment-char))
(setq-local comment-add 1)
(setq-local comment-start-skip "\\(?:\\s<+\\|/[/*]+\\)[ \t]*")
(setq-local comment-end-skip "[ \t]*\\(\\s>\\|\\*+/\\)")
(setq-local comment-end ""))
(defun asm-indent-line ()
"Auto-indent the current line."
(interactive)
(let* ((savep (point))
(indent (condition-case nil
(save-excursion
(forward-line 0)
(skip-chars-forward " \t")
(if (>= (point) savep) (setq savep nil))
(max (asm-calculate-indentation) 0))
(error 0))))
(if savep
(save-excursion (indent-line-to indent))
(indent-line-to indent))))
(defun asm-calculate-indentation ()
(or
;; Flush labels to the left margin.
(and (looking-at "\\(\\sw\\|\\s_\\)+:") 0)
;; Same thing for `;;;' comments.
(and (looking-at "\\s<\\s<\\s<") 0)
;; Simple `;' comments go to the comment-column.
(and (looking-at "\\s<\\(\\S<\\|\\'\\)") comment-column)
;; The rest goes at the first tab stop.
(indent-next-tab-stop 0)))
(defun asm-colon ()
"Insert a colon; if it follows a label, delete the label's indentation."
(interactive)
(let ((labelp nil))
(save-excursion
(skip-syntax-backward "w_")
(skip-syntax-backward " ")
(if (setq labelp (bolp)) (delete-horizontal-space)))
(call-interactively 'self-insert-command)
(when labelp
(delete-horizontal-space)
(tab-to-tab-stop))))
(define-obsolete-function-alias 'asm-newline #'newline-and-indent "27.1")
(defun asm-comment ()
"Convert an empty comment to a `larger' kind, or start a new one.
These are the known comment classes:
1 -- comment to the right of the code (at the `comment-column')
2 -- comment on its own line, indented like code
3 -- comment on its own line, beginning at the left-most column.
Suggested usage: while writing your code, trigger asm-comment
repeatedly until you are satisfied with the kind of comment."
(interactive)
(comment-normalize-vars)
(let (comempty comment)
(save-excursion
(beginning-of-line)
(with-no-warnings
(setq comment (comment-search-forward (line-end-position) t)))
(setq comempty (looking-at "[ \t]*$")))
(cond
;; Blank line? Then start comment at code indent level.
;; Just like `comment-dwim'. -stef
((save-excursion (beginning-of-line) (looking-at "^[ \t]*$"))
(indent-according-to-mode)
(insert asm-comment-char asm-comment-char ?\ ))
;; Nonblank line w/o comment => start a comment at comment-column.
;; Also: point before the comment => jump inside.
((or (null comment) (< (point) comment))
(indent-for-comment))
;; Flush-left or non-empty comment present => just insert character.
((or (not comempty) (save-excursion (goto-char comment) (bolp)))
(insert asm-comment-char))
;; Empty code-level comment => upgrade to next comment level.
((save-excursion (goto-char comment) (skip-chars-backward " \t") (bolp))
(goto-char comment)
(insert asm-comment-char)
(indent-for-comment))
;; Empty comment ends non-empty code line => new comment above.
(t
(goto-char comment)
(skip-chars-backward " \t")
(delete-region (point) (line-end-position))
(beginning-of-line) (insert "\n") (backward-char)
(asm-comment)))))
(provide 'asm-mode)
;;; asm-mode.el ends here
|
