|
0
|
1 ;;;; psgml-dtd.el --- DTD parser for SGML-editing mode with parsing support
|
|
2
|
2 ;; $Id: psgml-dtd.el,v 1.1.1.2 1996/12/18 03:47:13 steve Exp $
|
|
0
|
3
|
|
|
4 ;; Copyright (C) 1994 Lennart Staflin
|
|
|
5
|
|
|
6 ;; Author: Lennart Staflin <lenst@lysator.liu.se>
|
|
|
7
|
|
|
8 ;; This program is free software; you can redistribute it and/or
|
|
|
9 ;; modify it under the terms of the GNU General Public License
|
|
|
10 ;; as published by the Free Software Foundation; either version 2
|
|
|
11 ;; of the License, or (at your option) any later version.
|
|
|
12 ;;
|
|
|
13 ;; This program is distributed in the hope that it will be useful,
|
|
|
14 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
15 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
16 ;; GNU General Public License for more details.
|
|
|
17 ;;
|
|
|
18 ;; You should have received a copy of the GNU General Public License
|
|
|
19 ;; along with this program; if not, write to the Free Software
|
|
|
20 ;; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
21
|
|
|
22
|
|
|
23 ;;;; Commentary:
|
|
|
24
|
|
|
25 ;; Part of major mode for editing the SGML document-markup language.
|
|
|
26
|
|
|
27
|
|
|
28 ;;;; Code:
|
|
|
29
|
|
|
30 (provide 'psgml-dtd)
|
|
|
31 (require 'psgml)
|
|
|
32 (require 'psgml-parse)
|
|
|
33
|
|
|
34
|
|
|
35 ;;;; Variables
|
|
|
36
|
|
|
37 ;; Variables used during doctype parsing and loading
|
|
|
38 (defvar sgml-used-pcdata nil
|
|
|
39 "True if model group built is mixed")
|
|
|
40
|
|
|
41
|
|
|
42 ;;;; Constructing basic
|
|
|
43
|
|
|
44 (defun sgml-copy-moves (s1 s2)
|
|
|
45 "Copy all moves from S1 to S2, keeping their status."
|
|
|
46 (let ((l (sgml-state-opts s1)))
|
|
|
47 (while l
|
|
|
48 (sgml-add-opt-move s2
|
|
|
49 (sgml-move-token (car l))
|
|
|
50 (sgml-move-dest (car l)))
|
|
|
51 (setq l (cdr l)))
|
|
|
52 (setq l (sgml-state-reqs s1))
|
|
|
53 (while l
|
|
|
54 (sgml-add-req-move s2
|
|
|
55 (sgml-move-token (car l))
|
|
|
56 (sgml-move-dest (car l)))
|
|
|
57 (setq l (cdr l)))))
|
|
|
58
|
|
|
59 (defun sgml-copy-moves-to-opt (s1 s2)
|
|
|
60 "Copy all moves from S1 to S2 as optional moves."
|
|
|
61 (let ((l (sgml-state-opts s1)))
|
|
|
62 (while l
|
|
|
63 (sgml-add-opt-move s2
|
|
|
64 (sgml-move-token (car l))
|
|
|
65 (sgml-move-dest (car l)))
|
|
|
66 (setq l (cdr l)))
|
|
|
67 (setq l (sgml-state-reqs s1))
|
|
|
68 (while l
|
|
|
69 (sgml-add-opt-move s2
|
|
|
70 (sgml-move-token (car l))
|
|
|
71 (sgml-move-dest (car l)))
|
|
|
72 (setq l (cdr l)))))
|
|
|
73
|
|
|
74
|
|
|
75 (defun sgml-some-states-of (state)
|
|
|
76 ;; List of some states reachable from STATE, includes all final states
|
|
|
77 (let* ((states (list state))
|
|
|
78 (l states)
|
|
|
79 s ms m)
|
|
|
80 (while l
|
|
|
81 (setq s (car l)
|
|
|
82 ms (append (sgml-state-opts s) (sgml-state-reqs s)))
|
|
|
83 (while ms
|
|
|
84 (setq m (sgml-move-dest (car ms))
|
|
|
85 ms (cdr ms))
|
|
|
86 (unless (sgml-normal-state-p m)
|
|
2
|
87 (setq m (sgml-and-node-next m)))
|
|
0
|
88 (unless (memq m states)
|
|
|
89 (nconc states (list m))))
|
|
|
90 (setq l (cdr l)))
|
|
|
91 states))
|
|
|
92
|
|
|
93 (defmacro sgml-for-all-final-states (s dfa &rest forms)
|
|
|
94 "For all final states S in DFA do FORMS.
|
|
|
95 Syntax: var dfa-expr &body forms"
|
|
|
96 (` (let ((L-states (sgml-some-states-of (, dfa)))
|
|
|
97 (, s))
|
|
|
98 (while L-states
|
|
|
99 (when (sgml-state-final-p (setq (, s) (car L-states)))
|
|
|
100 (,@ forms))
|
|
|
101 (setq L-states (cdr L-states))))))
|
|
|
102
|
|
|
103 (put 'sgml-for-all-final-states 'lisp-indent-hook 2)
|
|
|
104 (put 'sgml-for-all-final-states 'edebug-form-hook '(symbolp &rest form))
|
|
|
105
|
|
|
106
|
|
|
107 ;;;; Optimization for the dfa building
|
|
|
108
|
|
|
109 (defsubst sgml-empty-state-p (s)
|
|
|
110 ;; True if S hase no outgoing moves
|
|
|
111 (and (sgml-normal-state-p s)
|
|
|
112 (null (sgml-state-reqs s))
|
|
|
113 (null (sgml-state-opts s))) )
|
|
|
114
|
|
|
115 (defun sgml-one-final-state (s)
|
|
|
116 ;; Collaps all states that have no moves
|
|
|
117 ;; This is a safe optimization, useful for (..|..|..)
|
|
|
118 (sgml-debug "OPT one final: reqs %d opts %d"
|
|
|
119 (length (sgml-state-reqs s))
|
|
|
120 (length (sgml-state-opts s)))
|
|
|
121 (let ((final nil)
|
|
|
122 dest)
|
|
|
123 (loop for m in (append (sgml-state-reqs s)
|
|
|
124 (sgml-state-opts s))
|
|
|
125 do
|
|
|
126 (setq dest (sgml-move-dest m))
|
|
|
127 (when (sgml-empty-state-p dest)
|
|
|
128 (cond ((null final)
|
|
|
129 (setq final dest))
|
|
|
130 (t
|
|
|
131 (setf (sgml-move-dest m) final)))))))
|
|
|
132
|
|
|
133 (defun sgml-states-equal (s1 s2)
|
|
|
134 (and (= (length (sgml-state-opts s1))
|
|
|
135 (length (sgml-state-opts s2)))
|
|
|
136 (= (length (sgml-state-reqs s1))
|
|
|
137 (length (sgml-state-reqs s2)))
|
|
|
138 (loop for m in (sgml-state-opts s1)
|
|
|
139 always
|
|
|
140 (eq (sgml-move-dest m)
|
|
|
141 (sgml-move-dest (sgml-moves-lookup (sgml-move-token m)
|
|
|
142 (sgml-state-opts s2)))))
|
|
|
143 (loop for m in (sgml-state-reqs s1)
|
|
|
144 always
|
|
|
145 (eq (sgml-move-dest m)
|
|
|
146 (sgml-move-dest (sgml-moves-lookup (sgml-move-token m)
|
|
|
147 (sgml-state-reqs s2)))))))
|
|
|
148
|
|
|
149 (defun sgml-remove-redundant-states-1 (s)
|
|
|
150 ;; Remove states accessible from s with one move and equivalent to s,
|
|
|
151 ;; by changing the moves from s.
|
|
|
152 (sgml-debug "OPT redundant-1: reqs %d opts %d"
|
|
|
153 (length (sgml-state-reqs s))
|
|
|
154 (length (sgml-state-opts s)))
|
|
|
155 (let ((yes nil)
|
|
|
156 (no (list s))
|
|
|
157 (l (sgml-state-reqs s))
|
|
|
158 (nl (sgml-state-opts s))
|
|
|
159 dest)
|
|
|
160 (while (or l (setq l (prog1 nl (setq nl nil))))
|
|
|
161 (cond
|
|
|
162 ((not (sgml-normal-state-p (setq dest (sgml-move-dest (car l))))))
|
|
|
163 ((memq dest no))
|
|
|
164 ((memq dest yes))
|
|
|
165 ((sgml-states-equal s dest)
|
|
|
166 (progn (push dest yes))))
|
|
|
167 (setq l (cdr l)))
|
|
|
168 (setq l (sgml-state-opts s)
|
|
|
169 nl (sgml-state-reqs s))
|
|
|
170 (when yes
|
|
|
171 (sgml-debug "OPT redundant-1: sucess %s" (length yes))
|
|
|
172 (while (or l (setq l (prog1 nl (setq nl nil))))
|
|
|
173 (cond ((memq (sgml-move-dest (car l)) yes)
|
|
|
174 (setf (sgml-move-dest (car l)) s)))
|
|
|
175 (setq l (cdr l))))))
|
|
|
176
|
|
|
177
|
|
|
178
|
|
|
179 ;;;; Constructing
|
|
|
180
|
|
|
181 (defun sgml-make-opt (s1)
|
|
|
182 (when (sgml-state-reqs s1)
|
|
|
183 (setf (sgml-state-opts s1)
|
|
|
184 (nconc (sgml-state-opts s1)
|
|
|
185 (sgml-state-reqs s1)))
|
|
|
186 (setf (sgml-state-reqs s1) nil))
|
|
|
187 s1)
|
|
|
188
|
|
|
189 (defun sgml-make-* (s1)
|
|
|
190 (setq s1 (sgml-make-+ s1))
|
|
|
191 (when (sgml-state-reqs s1)
|
|
|
192 (sgml-make-opt s1))
|
|
|
193 (sgml-remove-redundant-states-1 s1)
|
|
|
194 s1)
|
|
|
195
|
|
|
196 (defun sgml-make-+ (s1)
|
|
|
197 (sgml-for-all-final-states s s1
|
|
|
198 (sgml-copy-moves-to-opt s1 s))
|
|
|
199 (sgml-remove-redundant-states-1 s1) ; optimize
|
|
|
200 s1)
|
|
|
201
|
|
|
202 (defun sgml-make-conc (s1 s2)
|
|
|
203 (let ((moves (append (sgml-state-reqs s1) (sgml-state-opts s1))))
|
|
|
204 (cond
|
|
|
205 (;; optimize the case where all moves from s1 goes to empty states
|
|
|
206 (loop for m in moves
|
|
|
207 always (sgml-empty-state-p (sgml-move-dest m)))
|
|
|
208 (loop for m in moves do (setf (sgml-move-dest m) s2))
|
|
|
209 (when (sgml-state-final-p s1)
|
|
|
210 (sgml-copy-moves s2 s1)))
|
|
|
211 (t ; general case
|
|
|
212 (sgml-for-all-final-states s s1
|
|
|
213 (sgml-copy-moves s2 s)
|
|
|
214 (sgml-remove-redundant-states-1 s)))))
|
|
|
215 s1)
|
|
|
216
|
|
|
217 (defun sgml-make-pcdata ()
|
|
|
218 (sgml-make-* (sgml-make-primitive-content-token sgml-pcdata-token)))
|
|
|
219
|
|
|
220 (defun sgml-reduce-, (l)
|
|
|
221 (while (cdr l)
|
|
|
222 (setcar (cdr l)
|
|
|
223 (sgml-make-conc (car l) (cadr l)))
|
|
|
224 (setq l (cdr l)))
|
|
|
225 (car l))
|
|
|
226
|
|
|
227 (defun sgml-reduce-| (l)
|
|
|
228 (while (cdr l) ; apply the binary make-alt
|
|
|
229 (cond ((or (sgml-state-final-p (car l)) ; is result optional
|
|
|
230 (sgml-state-final-p (cadr l)))
|
|
|
231 (sgml-make-opt (car l))
|
|
|
232 (sgml-copy-moves-to-opt (cadr l) (car l)))
|
|
|
233 (t
|
|
|
234 (sgml-copy-moves (cadr l) (car l))))
|
|
|
235 (setcdr l (cddr l)))
|
|
|
236 (sgml-one-final-state (car l)) ; optimization
|
|
|
237 (car l))
|
|
|
238
|
|
|
239 (defun sgml-make-& (dfas)
|
|
2
|
240 (let ((&n (sgml-make-and-node dfas (sgml-make-state)))
|
|
0
|
241 (s (sgml-make-state))
|
|
|
242 (l dfas))
|
|
|
243 (while l ; For each si:
|
|
|
244 ;; For m in opts(si): add optional move from s to &n on token(m).
|
|
|
245 (loop for m in (sgml-state-opts (car l))
|
|
|
246 do (sgml-add-opt-move s (sgml-move-token m) &n))
|
|
|
247 ;; For m in reqs(si): add required move from s to &n on token(m).
|
|
|
248 (loop for m in (sgml-state-reqs (car l))
|
|
|
249 do (sgml-add-req-move s (sgml-move-token m) &n))
|
|
|
250 (setq l (cdr l)))
|
|
|
251 ;; Return s.
|
|
|
252 s))
|
|
|
253
|
|
|
254
|
|
|
255
|
|
|
256 ;(sgml-make-conc (sgml-make-primitive-content-token 'para) (sgml-make-primitive-content-token 'list))
|
|
|
257 ;(sgml-make-conc (sgml-make-& (list (sgml-make-primitive-content-token 'para) (sgml-make-primitive-content-token 'list))) (sgml-make-primitive-content-token 'foo))
|
|
|
258
|
|
|
259 ;(setq x (sgml-some-states-of (sgml-make-primitive-content-token 'para)))
|
|
|
260 ;(sgml-state-final-p (car x) )
|
|
|
261 ;(sgml-state-final-p (cadr x))
|
|
|
262
|
|
|
263
|
|
|
264 ;;;; Parse doctype: General
|
|
|
265
|
|
|
266 (defun sgml-skip-ts ()
|
|
|
267 ;; Skip over ts*
|
|
|
268 ;;70 ts = 5 s | EE | 60+ parameter entity reference
|
|
|
269 ;;For simplicity I use ps*
|
|
|
270 ;;65 ps = 5 s | EE | 60+ parameter entity reference | 92 comment
|
|
|
271 ;;*** some comments are accepted that shouldn't
|
|
|
272 (sgml-skip-ps))
|
|
|
273
|
|
|
274 (defun sgml-parse-character-reference (&optional dofunchar)
|
|
|
275 ;; *** Actually only numerical character references
|
|
|
276 ;; I don't know how to handel the function character references.
|
|
|
277 ;; For the shortrefs let's give them numeric values.
|
|
|
278 (if (if dofunchar
|
|
|
279 (sgml-parse-delim "CRO" (digit nmstart))
|
|
|
280 (sgml-parse-delim "CRO" (digit)))
|
|
|
281 (prog1 (if (sgml-is-delim "NULL" digit)
|
|
|
282 (string-to-int (sgml-check-nametoken))
|
|
|
283 (let ((spec (sgml-check-name)))
|
|
|
284 (or (cdr (assoc spec '(("re" . 10)
|
|
|
285 ("rs" . 1)
|
|
|
286 ("tab" . 9)
|
|
|
287 ("space" . 32))))
|
|
|
288 ;; *** What to do with other names?
|
|
|
289 127)))
|
|
|
290 (or (sgml-parse-delim "REFC")
|
|
|
291 (sgml-parse-RE)))))
|
|
|
292
|
|
|
293 (defun sgml-parse-parameter-literal (&optional dofunchar)
|
|
|
294 (let* (lita ; flag if lita
|
|
|
295 (value ; accumulates literals value
|
|
|
296 "")
|
|
|
297 (original-buffer ; Buffer (entity) where lit started
|
|
|
298 (current-buffer))
|
|
|
299 temp
|
|
|
300 )
|
|
|
301 (cond
|
|
|
302 ((or (sgml-parse-delim "LIT")
|
|
|
303 (setq lita (sgml-parse-delim "LITA")))
|
|
|
304 (while (not (and (eq (current-buffer) original-buffer)
|
|
|
305 (if lita
|
|
|
306 (sgml-parse-delim "LITA")
|
|
|
307 (sgml-parse-delim "LIT"))))
|
|
|
308 (cond ((eobp)
|
|
|
309 (or (sgml-pop-entity)
|
|
|
310 (sgml-error "Parameter literal unterminated")))
|
|
|
311 ((sgml-parse-parameter-entity-ref))
|
|
|
312 ((setq temp (sgml-parse-character-reference dofunchar))
|
|
|
313 (setq value (concat value (format "%c" temp))))
|
|
|
314 (t
|
|
|
315 (setq value
|
|
|
316 (concat value
|
|
|
317 (buffer-substring
|
|
|
318 (point)
|
|
|
319 (progn (forward-char 1)
|
|
|
320 (if lita
|
|
|
321 (sgml-skip-upto ("LITA" "PERO" "CRO"))
|
|
|
322 (sgml-skip-upto ("LIT" "PERO" "CRO")))
|
|
|
323 (point)))))))
|
|
|
324 )
|
|
|
325 value))))
|
|
|
326
|
|
|
327 (defun sgml-check-parameter-literal ()
|
|
|
328 (or (sgml-parse-parameter-literal)
|
|
|
329 (sgml-parse-error "Parameter literal expected")))
|
|
|
330
|
|
|
331 (defsubst sgml-parse-connector ()
|
|
|
332 (sgml-skip-ps)
|
|
|
333 (cond ((sgml-parse-delim "SEQ")
|
|
|
334 (function sgml-reduce-,))
|
|
|
335 ((sgml-parse-delim "OR")
|
|
|
336 (function sgml-reduce-|))
|
|
|
337 ((sgml-parse-delim "AND")
|
|
|
338 (function sgml-make-&))))
|
|
|
339
|
|
|
340 (defun sgml-parse-name-group ()
|
|
|
341 "Parse a single name or a name group (general name case) .
|
|
|
342 Returns a list of strings or nil."
|
|
|
343 (let (names)
|
|
|
344 (cond
|
|
|
345 ((sgml-parse-delim "GRPO")
|
|
|
346 (sgml-skip-ps)
|
|
|
347 (setq names (sgml-parse-name-group)) ; *** Allows more than it should
|
|
|
348 (while (sgml-parse-connector)
|
|
|
349 (sgml-skip-ps)
|
|
|
350 (nconc names (sgml-parse-name-group)))
|
|
|
351 (sgml-check-delim "GRPC")
|
|
|
352 names)
|
|
|
353 ((setq names (sgml-parse-name))
|
|
|
354 (list names)))))
|
|
|
355
|
|
|
356 (defun sgml-check-name-group ()
|
|
|
357 (or (sgml-parse-name-group)
|
|
|
358 (sgml-parse-error "Expecting a name or a name group")))
|
|
|
359
|
|
|
360 (defun sgml-check-nametoken-group ()
|
|
|
361 "Parse a name token group, return a list of strings.
|
|
|
362 Case transformed for general names."
|
|
|
363 (sgml-skip-ps)
|
|
|
364 (let ((names nil))
|
|
|
365 (cond
|
|
|
366 ((sgml-parse-delim GRPO)
|
|
|
367 (while (progn
|
|
|
368 (sgml-skip-ps)
|
|
|
369 (push (sgml-general-case (sgml-check-nametoken)) names)
|
|
|
370 (sgml-parse-connector)))
|
|
|
371 (sgml-check-delim GRPC)
|
|
|
372 (nreverse names)) ; store in same order as declared
|
|
|
373 (t
|
|
|
374 (list (sgml-general-case (sgml-check-nametoken)))))))
|
|
|
375
|
|
|
376 (defun sgml-check-element-type ()
|
|
|
377 "Parse and check an element type, returns list of strings."
|
|
|
378 ;;; 117 element type = [[30 generic identifier]]
|
|
|
379 ;;; | [[69 name group]]
|
|
|
380 ;;; | [[118 ranked element]]
|
|
|
381 ;;; | [[119 ranked group]]
|
|
|
382 (cond
|
|
|
383 ((sgml-parse-delim GRPO)
|
|
|
384 (sgml-skip-ts)
|
|
|
385 (let ((names (list (sgml-check-name))))
|
|
|
386 (while (progn (sgml-skip-ts)
|
|
|
387 (sgml-parse-connector))
|
|
|
388 (sgml-skip-ts)
|
|
|
389 (nconc names (list (sgml-check-name))))
|
|
|
390 (sgml-check-delim GRPC)
|
|
|
391 ;; A ranked group will have a rank suffix here
|
|
|
392 (sgml-skip-ps)
|
|
|
393 (if (sgml-is-delim "NULL" digit)
|
|
|
394 (let ((suffix (sgml-parse-nametoken)))
|
|
|
395 (loop for n in names
|
|
|
396 collect (concat n suffix)))
|
|
|
397 names)))
|
|
|
398 (t ; gi/ranked element
|
|
|
399 (let ((name (sgml-check-name)))
|
|
|
400 (sgml-skip-ps)
|
|
|
401 (list (if (sgml-is-delim "NULL" digit)
|
|
|
402 (concat name (sgml-check-nametoken))
|
|
|
403 name))))))
|
|
|
404
|
|
|
405
|
|
|
406 (defun sgml-check-external ()
|
|
|
407 (or (sgml-parse-external)
|
|
|
408 (sgml-parse-error "Expecting a PUBLIC or SYSTEM")))
|
|
|
409
|
|
|
410 ;;;; Parse doctype: notation
|
|
|
411
|
|
|
412 (defun sgml-declare-notation ()
|
|
|
413 ;;148 notation declaration = MDO, "NOTATION",
|
|
|
414 ;; 65 ps+, 41 notation name,
|
|
|
415 ;; 65 ps+, 149 notation identifier,
|
|
|
416 ;; 65 ps*, MDC
|
|
|
417 ;;41 notation name = 55 name
|
|
|
418 ;;149 notation identifier = 73 external identifier
|
|
|
419 (sgml-skip-ps)
|
|
|
420 (sgml-check-name)
|
|
|
421 (sgml-skip-ps)
|
|
|
422 (sgml-check-external))
|
|
|
423
|
|
|
424
|
|
|
425 ;;;; Parse doctype: Element
|
|
|
426
|
|
|
427 (defun sgml-parse-opt ()
|
|
|
428 (sgml-skip-ps)
|
|
|
429 (cond ((or (sgml-parse-char ?o)
|
|
|
430 (sgml-parse-char ?O))
|
|
|
431 t)
|
|
|
432 ((sgml-parse-char ?-)
|
|
|
433 nil)))
|
|
|
434
|
|
|
435 (defun sgml-parse-modifier ()
|
|
|
436 (cond ((sgml-parse-delim PLUS)
|
|
|
437 (function sgml-make-+))
|
|
|
438 ((sgml-parse-delim REP)
|
|
|
439 (function sgml-make-*))
|
|
|
440 ((sgml-parse-delim OPT)
|
|
|
441 (function sgml-make-opt))))
|
|
|
442
|
|
|
443 (defun sgml-check-primitive-content-token ()
|
|
|
444 (sgml-make-primitive-content-token
|
|
|
445 (sgml-eltype-token
|
|
|
446 (sgml-lookup-eltype
|
|
|
447 (sgml-check-name)))))
|
|
|
448
|
|
|
449 (defun sgml-check-model-group ()
|
|
|
450 (sgml-skip-ps)
|
|
|
451 (let (el mod)
|
|
|
452 (cond
|
|
|
453 ((sgml-parse-delim "GRPO")
|
|
|
454 (let ((subs (list (sgml-check-model-group)))
|
|
|
455 (con1 nil)
|
|
|
456 (con2 nil))
|
|
|
457 (while (setq con2 (sgml-parse-connector))
|
|
|
458 (cond ((and con1
|
|
|
459 (not (eq con1 con2)))
|
|
|
460 (sgml-parse-error "Mixed connectors")))
|
|
|
461 (setq con1 con2)
|
|
|
462 (setq subs (nconc subs (list (sgml-check-model-group)))))
|
|
|
463 (sgml-check-delim "GRPC")
|
|
|
464 (setq el (if con1
|
|
|
465 (funcall con1 subs)
|
|
|
466 (car subs)))))
|
|
|
467 ((sgml-parse-rni "pcdata") ; #PCDATA
|
|
|
468 (setq sgml-used-pcdata t)
|
|
|
469 (setq el (sgml-make-pcdata)))
|
|
|
470 ((sgml-parse-delim "DTGO") ; data tag group
|
|
|
471 (sgml-skip-ts)
|
|
|
472 (let ((tok (sgml-check-primitive-content-token)))
|
|
|
473 (sgml-skip-ts) (sgml-check-delim "SEQ")
|
|
|
474 (sgml-skip-ts) (sgml-check-data-tag-pattern)
|
|
|
475 (sgml-skip-ts) (sgml-check-delim "DTGC")
|
|
|
476 (setq el (sgml-make-conc tok (sgml-make-pcdata)))
|
|
|
477 (setq sgml-used-pcdata t)))
|
|
|
478 (t
|
|
|
479 (setq el (sgml-check-primitive-content-token))))
|
|
|
480 (setq mod (sgml-parse-modifier))
|
|
|
481 (if mod
|
|
|
482 (funcall mod el)
|
|
|
483 el)))
|
|
|
484
|
|
|
485 (defun sgml-check-data-tag-pattern ()
|
|
|
486 ;; 134 data tag pattern
|
|
|
487 ;; template | template group
|
|
|
488 (cond ((sgml-parse-delim GRPO)
|
|
|
489 (sgml-skip-ts)
|
|
|
490 (sgml-check-parameter-literal) ; data tag template,
|
|
|
491 (while (progn (sgml-skip-ts)
|
|
|
492 (sgml-parse-delim OR))
|
|
|
493 (sgml-skip-ts)
|
|
|
494 (sgml-check-parameter-literal)) ; data tag template
|
|
|
495 (sgml-skip-ts)
|
|
|
496 (sgml-check-delim GRPC))
|
|
|
497 (t
|
|
|
498 (sgml-check-parameter-literal))) ; data tag template
|
|
|
499 (sgml-skip-ts)
|
|
|
500 (when (sgml-parse-delim SEQ)
|
|
|
501 (sgml-check-parameter-literal))) ; data tag padding template
|
|
|
502
|
|
|
503 (defun sgml-check-content-model ()
|
|
|
504 (sgml-check-model-group))
|
|
|
505
|
|
|
506 (defun sgml-check-content ()
|
|
|
507 (sgml-skip-ps)
|
|
|
508 (cond ((sgml-is-delim GRPO)
|
|
|
509 (sgml-check-content-model))
|
|
|
510 (t
|
|
|
511 ;; ANY, CDATA, RCDATA or EMPTY
|
|
|
512 (let ((dc (intern (upcase (sgml-check-name)))))
|
|
|
513 (when (eq dc 'ANY)
|
|
|
514 (setq sgml-used-pcdata t))
|
|
|
515 dc))))
|
|
|
516
|
|
|
517 (defun sgml-parse-exeption (type)
|
|
|
518 (sgml-skip-ps)
|
|
|
519 (if (sgml-parse-char type)
|
|
|
520 (mapcar (function sgml-lookup-eltype)
|
|
|
521 (sgml-check-name-group))))
|
|
|
522
|
|
|
523 (defun sgml-before-eltype-modification ()
|
|
|
524 ;;; (let ((merged (sgml-dtd-merged sgml-dtd-info)))
|
|
|
525 ;;; (when (and merged
|
|
|
526 ;;; (eq (sgml-dtd-eltypes sgml-dtd-info)
|
|
|
527 ;;; (sgml-dtd-eltypes (cdr merged))))
|
|
|
528 ;;; (setf (sgml-dtd-eltypes sgml-dtd-info)
|
|
|
529 ;;; (sgml-merge-eltypes (sgml-make-eltypes-table)
|
|
|
530 ;;; (sgml-dtd-eltypes sgml-dtd-info)))))
|
|
|
531 )
|
|
|
532
|
|
|
533 (defun sgml-declare-element ()
|
|
|
534 (let* ((names (sgml-check-element-type))
|
|
|
535 (stag-opt (sgml-parse-opt))
|
|
|
536 (etag-opt (sgml-parse-opt))
|
|
|
537 (sgml-used-pcdata nil)
|
|
|
538 (model (sgml-check-content))
|
|
|
539 (exclusions (sgml-parse-exeption ?-))
|
|
|
540 (inclusions (sgml-parse-exeption ?+)))
|
|
|
541 (sgml-before-eltype-modification)
|
|
|
542 (while names
|
|
|
543 (sgml-debug "Defining element %s" (car names))
|
|
|
544 (let ((et (sgml-lookup-eltype (car names))))
|
|
|
545 (setf (sgml-eltype-stag-optional et) stag-opt
|
|
|
546 (sgml-eltype-etag-optional et) etag-opt
|
|
|
547 (sgml-eltype-model et) model
|
|
|
548 (sgml-eltype-mixed et) sgml-used-pcdata
|
|
|
549 (sgml-eltype-excludes et) exclusions
|
|
|
550 (sgml-eltype-includes et) inclusions))
|
|
|
551 (setq names (cdr names)))
|
|
|
552 (sgml-lazy-message "Parsing doctype (%s elements)..."
|
|
|
553 (incf sgml-no-elements))))
|
|
|
554
|
|
|
555 ;;;; Parse doctype: Entity
|
|
|
556
|
|
|
557 (defun sgml-declare-entity ()
|
|
|
558 (let (name ; Name of entity
|
|
|
559 dest ; Entity table
|
|
|
560 (type 'text) ; Type of entity
|
|
|
561 text ; Text of entity
|
|
|
562 extid ; External id
|
|
|
563 )
|
|
|
564 (cond
|
|
|
565 ((sgml-parse-delim "PERO") ; parameter entity declaration
|
|
|
566 (sgml-skip-ps)
|
|
|
567 (setq name (sgml-check-name t))
|
|
|
568 (setq dest (sgml-dtd-parameters sgml-dtd-info)))
|
|
|
569 (t ; normal entity declaration
|
|
|
570 (or (sgml-parse-rni "default")
|
|
|
571 (setq name (sgml-check-name t)))
|
|
|
572 (setq dest (sgml-dtd-entities sgml-dtd-info))))
|
|
|
573 (sgml-skip-ps)
|
|
|
574 ;;105 entity text = 66 parameter literal
|
|
|
575 ;; | 106 data text
|
|
|
576 ;; | 107 bracketed text
|
|
|
577 ;; | 108 external entity specification
|
|
|
578 (setq extid (sgml-parse-external))
|
|
|
579 (setq text
|
|
|
580 (cond
|
|
|
581 (extid ; external entity specification =
|
|
|
582 ; 73 external identifier,
|
|
|
583 ; (65 ps+, 109+ entity type)?
|
|
|
584 (sgml-skip-ps)
|
|
|
585 (setq type (or (sgml-parse-entity-type) 'text))
|
|
|
586 extid)
|
|
|
587 ((sgml-startnm-char-next)
|
|
|
588 (let ((token (intern (sgml-check-name))))
|
|
|
589 (sgml-skip-ps)
|
|
|
590 (cond
|
|
|
591 ((memq token '(cdata sdata)) ; data text ***
|
|
|
592 (setq type token)
|
|
|
593 (sgml-check-parameter-literal))
|
|
|
594 ((eq token 'pi)
|
|
|
595 (concat "<?" (sgml-check-parameter-literal) ">"))
|
|
|
596 ((eq token 'starttag)
|
|
|
597 (sgml-start-tag-of (sgml-check-parameter-literal)))
|
|
|
598 ((eq token 'endtag)
|
|
|
599 (sgml-end-tag-of (sgml-check-parameter-literal)))
|
|
|
600 ((eq token 'ms) ; marked section
|
|
|
601 (concat "<![" (sgml-check-parameter-literal) "]]>"))
|
|
|
602 ((eq token 'md) ; Markup declaration
|
|
|
603 (concat "<!" (sgml-check-parameter-literal) ">")))))
|
|
|
604 ((sgml-check-parameter-literal))))
|
|
|
605 (when dest
|
|
|
606 (sgml-entity-declare name dest type text))))
|
|
|
607
|
|
|
608
|
|
|
609 (defun sgml-parse-entity-type ()
|
|
|
610 ;;109+ entity type = "SUBDOC"
|
|
|
611 ;; | (("CDATA" | "NDATA" | "SDATA"),
|
|
|
612 ;; 65 ps+,
|
|
|
613 ;; 41 notation name,
|
|
|
614 ;; 149.2+ data attribute specification?)
|
|
|
615 (let ((type (sgml-parse-name)))
|
|
|
616 (when type
|
|
|
617 (setq type (intern (downcase type)))
|
|
|
618 (cond ((eq type 'subdoc))
|
|
|
619 ((memq type '(cdata ndata sdata))
|
|
|
620 (sgml-skip-ps)
|
|
|
621 (sgml-check-name)
|
|
|
622 ;;149.2+ data attribute specification
|
|
|
623 ;; = 65 ps+, DSO,
|
|
|
624 ;; 31 attribute specification list,
|
|
|
625 ;; 5 s*, DSC
|
|
|
626 (sgml-skip-ps)
|
|
|
627 (when (sgml-parse-delim DSO)
|
|
|
628 (sgml-parse-attribute-specification-list)
|
|
|
629 (sgml-parse-s)
|
|
|
630 (sgml-check-delim DSC)))
|
|
|
631 (t (sgml-error "Illegal entity type: %s" type))))
|
|
|
632 type))
|
|
|
633
|
|
|
634
|
|
|
635 ;;;; Parse doctype: Attlist
|
|
|
636
|
|
|
637 (defun sgml-declare-attlist ()
|
|
|
638 (let* ((assnot (cond ((sgml-parse-rni "notation")
|
|
|
639 (sgml-skip-ps)
|
|
|
640 t)))
|
|
|
641 (assel (sgml-check-name-group))
|
|
|
642 (attlist nil) ; the list
|
|
|
643 (attdef nil))
|
|
|
644 (while (setq attdef (sgml-parse-attribute-definition))
|
|
|
645 (push attdef attlist))
|
|
|
646 (setq attlist (nreverse attlist))
|
|
|
647 (unless assnot
|
|
|
648 (sgml-before-eltype-modification)
|
|
|
649 (loop for elname in assel do
|
|
|
650 (setf (sgml-eltype-attlist (sgml-lookup-eltype elname))
|
|
|
651 attlist)))))
|
|
|
652
|
|
|
653 (defun sgml-parse-attribute-definition ()
|
|
|
654 (sgml-skip-ps)
|
|
|
655 (if (sgml-is-delim MDC) ; End of attlist?
|
|
|
656 nil
|
|
|
657 (sgml-make-attdecl (sgml-check-name)
|
|
|
658 (sgml-check-declared-value)
|
|
|
659 (sgml-check-default-value))))
|
|
|
660
|
|
|
661 (defun sgml-check-declared-value ()
|
|
|
662 (sgml-skip-ps)
|
|
|
663 (let ((type 'name-token-group)
|
|
|
664 (names nil))
|
|
|
665 (unless (eq (following-char) ?\()
|
|
|
666 (setq type (intern (sgml-check-name)))
|
|
|
667 (sgml-skip-ps))
|
|
|
668 (when (memq type '(name-token-group notation))
|
|
|
669 (setq names (sgml-check-nametoken-group)))
|
|
|
670 (sgml-make-declared-value type names)))
|
|
|
671
|
|
|
672 (defun sgml-check-default-value ()
|
|
|
673 (sgml-skip-ps)
|
|
|
674 (let* ((rni (sgml-parse-rni))
|
|
|
675 (key (if rni (intern (sgml-check-name)))))
|
|
|
676 (sgml-skip-ps)
|
|
|
677 (sgml-make-default-value
|
|
|
678 key
|
|
|
679 (if (or (not rni) (eq key 'fixed))
|
|
|
680 (sgml-check-attribute-value-specification)))))
|
|
|
681
|
|
|
682
|
|
|
683 ;;;; Parse doctype: Shortref
|
|
|
684
|
|
|
685 ;;;150 short reference mapping declaration = MDO, "SHORTREF",
|
|
|
686 ;;; [[65 ps]]+, [[151 map name]],
|
|
|
687 ;;; ([[65 ps]]+, [[66 parameter literal]],
|
|
|
688 ;;; [[65 ps]]+, [[55 name]])+,
|
|
|
689 ;;; [[65 ps]]*, MDC
|
|
|
690
|
|
|
691 (defun sgml-declare-shortref ()
|
|
|
692 (let ((mapname (sgml-check-name))
|
|
|
693 mappings literal name)
|
|
|
694 (while (progn
|
|
|
695 (sgml-skip-ps)
|
|
|
696 (setq literal (sgml-parse-parameter-literal 'dofunchar)))
|
|
|
697 (sgml-skip-ps)
|
|
|
698 (setq name (sgml-check-name t))
|
|
|
699 (push (cons literal name) mappings))
|
|
|
700 (sgml-add-shortref-map
|
|
|
701 (sgml-dtd-shortmaps sgml-dtd-info)
|
|
|
702 mapname
|
|
|
703 (sgml-make-shortmap mappings))))
|
|
|
704
|
|
|
705 ;;;152 short reference use declaration = MDO, "USEMAP",
|
|
|
706 ;;; [[65 ps]]+, [[153 map specification]],
|
|
|
707 ;;; ([[65 ps]]+, [[72 associated element type]])?,
|
|
|
708 ;;; [[65 ps]]*, MDC
|
|
|
709
|
|
|
710 (defun sgml-do-usemap-element (mapname)
|
|
|
711 ;; This is called from sgml-do-usemap with the mapname
|
|
|
712 (sgml-before-eltype-modification)
|
|
|
713 (loop for e in (sgml-parse-name-group) do
|
|
|
714 (setf (sgml-eltype-shortmap (sgml-lookup-eltype e sgml-dtd-info))
|
|
|
715 (if (null mapname)
|
|
|
716 'empty
|
|
|
717 mapname))))
|
|
|
718
|
|
|
719
|
|
|
720 ;;;; Parse doctype
|
|
|
721
|
|
|
722 (defun sgml-check-dtd-subset ()
|
|
|
723 (let ((sgml-parsing-dtd t)
|
|
|
724 (eref sgml-current-eref))
|
|
|
725 (while
|
|
|
726 (progn
|
|
|
727 (setq sgml-markup-start (point))
|
|
|
728 (cond
|
|
|
729 ((and (eobp) (eq sgml-current-eref eref))
|
|
|
730 nil)
|
|
|
731 ((sgml-parse-ds))
|
|
|
732 ((sgml-parse-markup-declaration 'dtd))
|
|
|
733 ((sgml-parse-delim "MS-END")))))))
|
|
|
734
|
|
|
735
|
|
|
736 ;;;; Save DTD: compute translation
|
|
|
737
|
|
|
738 (defvar sgml-translate-table nil)
|
|
|
739
|
|
|
740 (defun sgml-translate-node (node)
|
|
|
741 (assert (not (numberp node)))
|
|
|
742 (let ((tp (assq node sgml-translate-table)))
|
|
|
743 (unless tp
|
|
|
744 (setq tp (cons node (length sgml-translate-table)))
|
|
|
745 (nconc sgml-translate-table (list tp)))
|
|
|
746 (cdr tp)))
|
|
|
747
|
|
|
748 (defun sgml-translate-moves (moves)
|
|
|
749 (while moves
|
|
|
750 (sgml-translate-node (sgml-move-dest (car moves)))
|
|
|
751 (setq moves (cdr moves))))
|
|
|
752
|
|
|
753 (defun sgml-translate-model (model)
|
|
|
754 (let* ((sgml-translate-table (list (cons model 0)))
|
|
|
755 (p sgml-translate-table))
|
|
|
756 (while p
|
|
|
757 (cond ((sgml-normal-state-p (caar p))
|
|
|
758 (sgml-translate-moves (sgml-state-opts (caar p)))
|
|
|
759 (sgml-translate-moves (sgml-state-reqs (caar p))))
|
|
|
760 (t
|
|
2
|
761 (sgml-translate-node (sgml-and-node-next (caar p)))))
|
|
0
|
762 (setq p (cdr p)))
|
|
|
763 sgml-translate-table))
|
|
|
764
|
|
|
765 ;;;; Save DTD: binary coding
|
|
|
766
|
|
|
767 (defvar sgml-code-token-numbers nil)
|
|
|
768 (defvar sgml-code-xlate nil)
|
|
|
769
|
|
|
770 (defsubst sgml-code-xlate (node)
|
|
|
771 ;;(let ((x (cdr (assq node sgml-code-xlate)))) (assert x) x)
|
|
|
772 (cdr (assq node sgml-code-xlate)))
|
|
|
773
|
|
|
774 (defun sgml-code-number (num)
|
|
|
775 (if (> num sgml-max-single-octet-number)
|
|
|
776 (insert (+ (lsh (- num sgml-max-single-octet-number) -8)
|
|
|
777 sgml-max-single-octet-number 1)
|
|
|
778 (logand (- num sgml-max-single-octet-number) 255))
|
|
|
779 (insert num)))
|
|
|
780
|
|
|
781 (defun sgml-code-token-number (token)
|
|
|
782 (let ((bp (assq token sgml-code-token-numbers)))
|
|
|
783 (unless bp
|
|
|
784 (setq sgml-code-token-numbers
|
|
|
785 (nconc sgml-code-token-numbers
|
|
|
786 (list (setq bp (cons token
|
|
|
787 (length sgml-code-token-numbers)))))))
|
|
|
788 (cdr bp)))
|
|
|
789
|
|
|
790 (defun sgml-code-token (token)
|
|
|
791 (sgml-code-number (sgml-code-token-number token)))
|
|
|
792
|
|
|
793 (defmacro sgml-code-sequence (loop-c &rest body)
|
|
|
794 "Produce the binary coding of a counted sequence from a list.
|
|
|
795 Syntax: (var seq) &body forms
|
|
|
796 FORMS should produce the binary coding of element in VAR."
|
|
|
797 (let ((var (car loop-c))
|
|
|
798 (seq (cadr loop-c)))
|
|
|
799 (` (let ((seq (, seq)))
|
|
|
800 (sgml-code-number (length seq))
|
|
|
801 (loop for (, var) in seq
|
|
|
802 do (,@ body))))))
|
|
|
803
|
|
|
804 (put 'sgml-code-sequence 'lisp-indent-hook 1)
|
|
|
805 (put 'sgml-code-sequence 'edbug-forms-hook '(sexp &rest form))
|
|
|
806
|
|
|
807 (defun sgml-code-sexp (sexp)
|
|
|
808 (let ((standard-output (current-buffer)))
|
|
|
809 (prin1 sexp)
|
|
|
810 (terpri)))
|
|
|
811
|
|
|
812 (defun sgml-code-tokens (l)
|
|
|
813 (sgml-code-sequence (x l)
|
|
|
814 (sgml-code-token x)))
|
|
|
815
|
|
|
816 (defsubst sgml-code-move (m)
|
|
|
817 (sgml-code-token (sgml-move-token m))
|
|
|
818 (insert (sgml-code-xlate (sgml-move-dest m))))
|
|
|
819
|
|
|
820 (defun sgml-code-model (m)
|
|
|
821 (let ((sgml-code-xlate (sgml-translate-model m)))
|
|
|
822 (sgml-code-sequence (s sgml-code-xlate) ; s is (node . number)
|
|
|
823 (setq s (car s)) ; s is node
|
|
|
824 (cond
|
|
|
825 ((sgml-normal-state-p s)
|
|
|
826 (assert (and (< (length (sgml-state-opts s)) 255)
|
|
|
827 (< (length (sgml-state-reqs s)) 256)))
|
|
|
828 (sgml-code-sequence (x (sgml-state-opts s))
|
|
|
829 (sgml-code-move x))
|
|
|
830 (sgml-code-sequence (x (sgml-state-reqs s))
|
|
|
831 (sgml-code-move x)))
|
|
|
832 (t ; s is a &-node
|
|
|
833 (insert 255) ; Tag &-node
|
|
2
|
834 (insert (sgml-code-xlate (sgml-and-node-next s)))
|
|
|
835 (sgml-code-sequence (m (sgml-and-node-dfas s))
|
|
0
|
836 (sgml-code-model m)))))))
|
|
|
837
|
|
|
838 (defun sgml-code-element (et)
|
|
|
839 (sgml-code-sexp (sgml-eltype-all-miscdata et))
|
|
|
840 (cond
|
|
|
841 ((not (sgml-eltype-defined et))
|
|
|
842 (insert 128))
|
|
|
843 (t
|
|
|
844 (insert (sgml-eltype-flags et))
|
|
|
845 (let ((c (sgml-eltype-model et)))
|
|
|
846 (cond ((eq c sgml-cdata) (insert 0))
|
|
|
847 ((eq c sgml-rcdata) (insert 1))
|
|
|
848 ((eq c sgml-empty) (insert 2))
|
|
|
849 ((eq c sgml-any) (insert 3))
|
|
|
850 ((null c) (insert 4))
|
|
|
851 (t
|
|
|
852 (assert (sgml-model-group-p c))
|
|
|
853 (insert 128)
|
|
|
854 (sgml-code-model c))))
|
|
|
855 (sgml-code-tokens (sgml-eltype-includes et))
|
|
|
856 (sgml-code-tokens (sgml-eltype-excludes et)))))
|
|
|
857
|
|
|
858
|
|
|
859 (defun sgml-code-dtd (dtd)
|
|
|
860 "Produce the binary coding of the current DTD into the current buffer."
|
|
|
861 (sgml-code-sexp (sgml-dtd-dependencies dtd))
|
|
|
862 (sgml-code-sexp (sgml-dtd-parameters dtd))
|
|
|
863 (sgml-code-sexp (sgml-dtd-doctype dtd))
|
|
|
864 (let ((done 0) ; count written elements
|
|
|
865 tot)
|
|
|
866 (setq sgml-code-token-numbers nil)
|
|
|
867 (sgml-code-token-number sgml-pcdata-token) ; Make #PCDATA token 0
|
|
|
868 (sgml-map-eltypes ; Assign numbers to all tokens
|
|
|
869 (function (lambda (et)
|
|
|
870 (sgml-code-token-number (sgml-eltype-token et))))
|
|
|
871 dtd nil t)
|
|
|
872 (setq tot (length sgml-code-token-numbers))
|
|
|
873 ;; Produce the counted sequence of element type names
|
|
|
874 (sgml-code-sequence (pair (cdr sgml-code-token-numbers))
|
|
|
875 (sgml-code-sexp (sgml-eltype-name (car pair))))
|
|
|
876 ;; Produce the counted sequence of element types
|
|
|
877 (sgml-code-sequence (pair (cdr sgml-code-token-numbers))
|
|
|
878 (setq done (1+ done))
|
|
|
879 (sgml-code-element (car pair))
|
|
|
880 (sgml-lazy-message "Saving DTD %d%% done" (/ (* 100 done) tot)))
|
|
|
881 (sgml-code-sexp (sgml-dtd-entities dtd))
|
|
|
882 (sgml-code-sexp (sgml-dtd-shortmaps dtd))
|
|
|
883 (sgml-code-sexp (sgml-dtd-notations dtd))))
|
|
|
884
|
|
|
885
|
|
|
886 ;;;; Save DTD
|
|
|
887
|
|
|
888 (defun sgml-save-dtd (file)
|
|
|
889 "Save the parsed dtd on FILE."
|
|
|
890 (interactive
|
|
|
891 (let* ((tem (expand-file-name
|
|
|
892 (or sgml-default-dtd-file
|
|
|
893 (sgml-default-dtd-file))))
|
|
|
894 (dir (file-name-directory tem))
|
|
|
895 (nam (file-name-nondirectory tem)))
|
|
|
896 (list
|
|
|
897 (read-file-name "Save DTD in: " dir tem nil nam))))
|
|
|
898 (setq file (expand-file-name file))
|
|
|
899 (when (equal file (buffer-file-name))
|
|
|
900 (error "Would clobber current file"))
|
|
|
901 (sgml-need-dtd)
|
|
|
902 (sgml-push-to-entity (sgml-make-entity "#SAVE" nil ""))
|
|
|
903 (sgml-write-dtd sgml-dtd-info file)
|
|
|
904 (sgml-pop-entity)
|
|
|
905 (setq sgml-default-dtd-file
|
|
|
906 (if (equal (expand-file-name default-directory)
|
|
|
907 (file-name-directory file))
|
|
|
908 (file-name-nondirectory file)
|
|
|
909 file))
|
|
|
910 (setq sgml-loaded-dtd file))
|
|
|
911
|
|
|
912 (defun sgml-write-dtd (dtd file)
|
|
|
913 "Save the parsed dtd on FILE.
|
|
|
914 Construct the binary coded DTD (bdtd) in the current buffer."
|
|
|
915 (insert
|
|
|
916 ";;; This file was created by psgml on " (current-time-string) "\n"
|
|
|
917 "(sgml-saved-dtd-version 6)\n")
|
|
|
918 (sgml-code-dtd dtd)
|
|
|
919 (setq file-type 1)
|
|
|
920 (write-region (point-min) (point-max) file))
|
|
|
921
|
|
|
922
|
|
|
923 ;;; psgml-dtd.el ends here
|
