27451
|
1 ;;; ebnf2ps --- Translate an EBNF to a syntatic chart on PostScript
|
|
2
|
|
3 ;; Copyright (C) 1999 Vinicius Jose Latorre
|
|
4
|
|
5 ;; Author: Vinicius Jose Latorre <vinicius@cpqd.com.br>
|
|
6 ;; Maintainer: Vinicius Jose Latorre <vinicius@cpqd.com.br>
|
|
7 ;; Keywords: wp, ebnf, PostScript
|
|
8 ;; Time-stamp: <99/12/11 21:41:24 vinicius>
|
|
9 ;; Version: 3.1
|
|
10
|
|
11 (defconst ebnf-version "3.1"
|
|
12 "ebnf2ps.el, v 3.1 <99/12/11 vinicius>
|
|
13
|
|
14 Vinicius's last change version. When reporting bugs, please also
|
|
15 report the version of Emacs, if any, that ebnf2ps was running with.
|
|
16
|
|
17 Please send all bug fixes and enhancements to
|
|
18 Vinicius Jose Latorre <vinicius@cpqd.com.br>.
|
|
19 ")
|
|
20
|
|
21 ;; This file is *NOT* (yet?) part of GNU Emacs.
|
|
22
|
|
23 ;; This program is free software; you can redistribute it and/or modify
|
|
24 ;; it under the terms of the GNU General Public License as published by
|
|
25 ;; the Free Software Foundation; either version 2, or (at your option)
|
|
26 ;; any later version.
|
|
27
|
|
28 ;; This program is distributed in the hope that it will be useful,
|
|
29 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
30 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
31 ;; GNU General Public License for more details.
|
|
32
|
|
33 ;; You should have received a copy of the GNU General Public License
|
|
34 ;; along with GNU Emacs; see the file COPYING. If not, write to the
|
|
35 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
36 ;; Boston, MA 02111-1307, USA.
|
|
37
|
|
38 ;;; Commentary:
|
|
39
|
|
40 ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
41 ;;
|
|
42 ;; Introduction
|
|
43 ;; ------------
|
|
44 ;;
|
|
45 ;; This package translates an EBNF to a syntatic chart on PostScript.
|
|
46 ;;
|
|
47 ;; To use ebnf2ps, insert in your ~/.emacs:
|
|
48 ;;
|
|
49 ;; (require 'ebnf2ps)
|
|
50 ;;
|
|
51 ;; ebnf2ps uses ps-print package (version 3.05.1 or later), so see ps-print to
|
|
52 ;; know how to set options like landscape printing, page headings, margins, etc.
|
|
53 ;;
|
|
54 ;; NOTE: ps-print zebra stripes and line number options doesn't have effect on
|
|
55 ;; ebnf2ps, they behave as it's turned off.
|
|
56 ;;
|
|
57 ;; For good performance, be sure to byte-compile ebnf2ps.el, e.g.
|
|
58 ;;
|
|
59 ;; M-x byte-compile-file <give the path to ebnf2ps.el when prompted>
|
|
60 ;;
|
|
61 ;; This will generate ebnf2ps.elc, which will be loaded instead of ebnf2ps.el.
|
|
62 ;;
|
|
63 ;; ebnf2ps was tested with GNU Emacs 20.4.1.
|
|
64 ;;
|
|
65 ;;
|
|
66 ;; Using ebnf2ps
|
|
67 ;; -------------
|
|
68 ;;
|
|
69 ;; ebnf2ps provides six commands for generating PostScript syntatic chart images
|
|
70 ;; of Emacs buffers:
|
|
71 ;;
|
|
72 ;; ebnf-print-buffer
|
|
73 ;; ebnf-print-region
|
|
74 ;; ebnf-spool-buffer
|
|
75 ;; ebnf-spool-region
|
|
76 ;; ebnf-eps-buffer
|
|
77 ;; ebnf-eps-region
|
|
78 ;;
|
|
79 ;; These commands all perform essentially the same function: they generate
|
|
80 ;; PostScript syntatic chart images suitable for printing on a PostScript
|
|
81 ;; printer or displaying with GhostScript. These commands are collectively
|
|
82 ;; referred to as "ebnf- commands".
|
|
83 ;;
|
|
84 ;; The word "print", "spool" and "eps" in the command name determines when the
|
|
85 ;; PostScript image is sent to the printer (or file):
|
|
86 ;;
|
|
87 ;; print - The PostScript image is immediately sent to the printer;
|
|
88 ;;
|
|
89 ;; spool - The PostScript image is saved temporarily in an Emacs buffer.
|
|
90 ;; Many images may be spooled locally before printing them. To
|
|
91 ;; send the spooled images to the printer, use the command
|
|
92 ;; `ebnf-despool'.
|
|
93 ;;
|
|
94 ;; eps - The PostScript image is immediately sent to a EPS file.
|
|
95 ;;
|
|
96 ;; The spooling mechanism is the same as used by ps-print and was designed for
|
|
97 ;; printing lots of small files to save paper that would otherwise be wasted on
|
|
98 ;; banner pages, and to make it easier to find your output at the printer (it's
|
|
99 ;; easier to pick up one 50-page printout than to find 50 single-page
|
|
100 ;; printouts). As ebnf2ps and ps-print use the same Emacs buffer to spool
|
|
101 ;; images, you can intermix the spooling of ebnf2ps and ps-print images.
|
|
102 ;;
|
|
103 ;; ebnf2ps use the same hook of ps-print in the `kill-emacs-hook' so that you
|
|
104 ;; won't accidentally quit from Emacs while you have unprinted PostScript
|
|
105 ;; waiting in the spool buffer. If you do attempt to exit with spooled
|
|
106 ;; PostScript, you'll be asked if you want to print it, and if you decline,
|
|
107 ;; you'll be asked to confirm the exit; this is modeled on the confirmation that
|
|
108 ;; Emacs uses for modified buffers.
|
|
109 ;;
|
|
110 ;; The word "buffer" or "region" in the command name determines how much of the
|
|
111 ;; buffer is printed:
|
|
112 ;;
|
|
113 ;; buffer - Print the entire buffer.
|
|
114 ;;
|
|
115 ;; region - Print just the current region.
|
|
116 ;;
|
|
117 ;; Two ebnf- command examples:
|
|
118 ;;
|
|
119 ;; ebnf-print-buffer - translate and print the entire buffer, and send
|
|
120 ;; it immediately to the printer.
|
|
121 ;;
|
|
122 ;; ebnf-spool-region - translate and print just the current region, and
|
|
123 ;; spool the image in Emacs to send to the printer
|
|
124 ;; later.
|
|
125 ;;
|
|
126 ;; Note that `ebnf-eps-buffer' and `ebnf-eps-region' never spool the EPS image,
|
|
127 ;; so they don't use the ps-print spooling mechanism. See section "Actions in
|
|
128 ;; Comments" for an explanation about EPS file generation.
|
|
129 ;;
|
|
130 ;;
|
|
131 ;; Invoking Ebnf2ps
|
|
132 ;; ----------------
|
|
133 ;;
|
|
134 ;; To translate and print your buffer, type
|
|
135 ;;
|
|
136 ;; M-x ebnf-print-buffer
|
|
137 ;;
|
|
138 ;; or substitute one of the other four ebnf- commands. The command will
|
|
139 ;; generate the PostScript image and print or spool it as specified. By giving
|
|
140 ;; the command a prefix argument
|
|
141 ;;
|
|
142 ;; C-u M-x ebnf-print-buffer
|
|
143 ;;
|
|
144 ;; it will save the PostScript image to a file instead of sending it to the
|
|
145 ;; printer; you will be prompted for the name of the file to save the image to.
|
|
146 ;; The prefix argument is ignored by the commands that spool their images, but
|
|
147 ;; you may save the spooled images to a file by giving a prefix argument to
|
|
148 ;; `ebnf-despool':
|
|
149 ;;
|
|
150 ;; C-u M-x ebnf-despool
|
|
151 ;;
|
|
152 ;; When invoked this way, `ebnf-despool' will prompt you for the name of the
|
|
153 ;; file to save to.
|
|
154 ;;
|
|
155 ;; The prefix argument is also ignored by `ebnf-eps-buffer' and
|
|
156 ;; `ebnf-eps-region'.
|
|
157 ;;
|
|
158 ;; Any of the `ebnf-' commands can be bound to keys. Here are some examples:
|
|
159 ;;
|
|
160 ;; (global-set-key 'f22 'ebnf-print-buffer) ;f22 is prsc
|
|
161 ;; (global-set-key '(shift f22) 'ebnf-print-region)
|
|
162 ;; (global-set-key '(control f22) 'ebnf-despool)
|
|
163 ;;
|
|
164 ;;
|
|
165 ;; EBNF Syntax
|
|
166 ;; -----------
|
|
167 ;;
|
|
168 ;; The current EBNF that ebnf2ps accepts has the following constructions:
|
|
169 ;;
|
|
170 ;; ; comment (until end of line)
|
|
171 ;; A non-terminal
|
|
172 ;; "C" terminal
|
|
173 ;; ?C? special
|
|
174 ;; $A default non-terminal (see text below)
|
|
175 ;; $"C" default terminal (see text below)
|
|
176 ;; $?C? default special (see text below)
|
|
177 ;; A = B. production (A is the header and B the body)
|
|
178 ;; C D sequence (C occurs before D)
|
|
179 ;; C | D alternative (C or D occurs)
|
|
180 ;; A - B exception (A excluding B, B without any non-terminal)
|
|
181 ;; n * A repetition (A repeats n (integer) times)
|
|
182 ;; (C) group (expression C is grouped together)
|
|
183 ;; [C] optional (C may or not occurs)
|
|
184 ;; C+ one or more occurrences of C
|
|
185 ;; {C}+ one or more occurrences of C
|
|
186 ;; {C}* zero or more occurrences of C
|
|
187 ;; {C} zero or more occurrences of C
|
|
188 ;; C / D equivalent to: C {D C}*
|
|
189 ;; {C || D}+ equivalent to: C {D C}*
|
|
190 ;; {C || D}* equivalent to: [C {D C}*]
|
|
191 ;; {C || D} equivalent to: [C {D C}*]
|
|
192 ;;
|
|
193 ;; The EBNF syntax written using the notation above is:
|
|
194 ;;
|
|
195 ;; EBNF = {production}+.
|
|
196 ;;
|
|
197 ;; production = non_terminal "=" body ".". ;; production
|
|
198 ;;
|
|
199 ;; body = {sequence || "|"}*. ;; alternative
|
|
200 ;;
|
|
201 ;; sequence = {exception}*. ;; sequence
|
|
202 ;;
|
|
203 ;; exception = repeat [ "-" repeat]. ;; exception
|
|
204 ;;
|
|
205 ;; repeat = [ integer "*" ] term. ;; repetition
|
|
206 ;;
|
|
207 ;; term = factor
|
|
208 ;; | [factor] "+" ;; one-or-more
|
|
209 ;; | [factor] "/" [factor] ;; one-or-more
|
|
210 ;; .
|
|
211 ;;
|
|
212 ;; factor = [ "$" ] "\"" terminal "\"" ;; terminal
|
|
213 ;; | [ "$" ] non_terminal ;; non-terminal
|
|
214 ;; | [ "$" ] "?" special "?" ;; special
|
|
215 ;; | "(" body ")" ;; group
|
|
216 ;; | "[" body "]" ;; zero-or-one
|
|
217 ;; | "{" body [ "||" body ] "}+" ;; one-or-more
|
|
218 ;; | "{" body [ "||" body ] "}*" ;; zero-or-more
|
|
219 ;; | "{" body [ "||" body ] "}" ;; zero-or-more
|
|
220 ;; .
|
|
221 ;;
|
|
222 ;; non_terminal = "[A-Za-z\\240-\\377][!#%&'*-,0-:<>@-Z\\^-z~\\240-\\377]*".
|
|
223 ;;
|
|
224 ;; terminal = "\\([^\"\\]\\|\\\\[ -~\\240-\\377]\\)+".
|
|
225 ;;
|
|
226 ;; special = "[^?\\n\\000-\\010\\016-\\037\\177-\\237]*".
|
|
227 ;;
|
|
228 ;; integer = "[0-9]+".
|
|
229 ;;
|
|
230 ;; comment = ";" "[^\\n\\000-\\010\\016-\\037\\177-\\237]*" "\\n".
|
|
231 ;;
|
|
232 ;; Try to use the above EBNF to test ebnf2ps.
|
|
233 ;;
|
|
234 ;; The `default' terminal, non-terminal and special is a way to indicate a
|
|
235 ;; default path in a production. For example, the production:
|
|
236 ;;
|
|
237 ;; X = [ $A ( B | $C ) | D ].
|
|
238 ;;
|
|
239 ;; Indicates that the default meaning for "X" is "A C" if "X" is empty.
|
|
240 ;;
|
|
241 ;; The terminal name is controlled by `ebnf-terminal-regexp' and
|
|
242 ;; `ebnf-case-fold-search', so it's possible to match other kind of terminal
|
|
243 ;; name besides that enclosed by `"'.
|
|
244 ;;
|
|
245 ;; Let's see an example:
|
|
246 ;;
|
|
247 ;; (setq ebnf-terminal-regexp "[A-Z][_A-Z]*") ; upper case name
|
|
248 ;; (setq ebnf-case-fold-search nil) ; exact matching
|
|
249 ;;
|
|
250 ;; If you have the production:
|
|
251 ;;
|
|
252 ;; Logical = "(" Expression ( OR | AND | "XOR" ) Expression ")".
|
|
253 ;;
|
|
254 ;; The names are classified as:
|
|
255 ;;
|
|
256 ;; Logical Expression non-terminal
|
|
257 ;; "(" OR AND "XOR" ")" terminal
|
|
258 ;;
|
|
259 ;; The line comment is controlled by `ebnf-lex-comment-char'. The default value
|
|
260 ;; is ?\; (character `;').
|
|
261 ;;
|
|
262 ;; The end of production is controlled by `ebnf-lex-eop-char'. The default
|
|
263 ;; value is ?. (character `.').
|
|
264 ;;
|
|
265 ;; The variable `ebnf-syntax' specifies which syntax to recognize:
|
|
266 ;;
|
|
267 ;; `ebnf' ebnf2ps recognizes the syntax described above.
|
|
268 ;; The following variables *ONLY* have effect with this
|
|
269 ;; setting:
|
|
270 ;; `ebnf-terminal-regexp', `ebnf-case-fold-search',
|
|
271 ;; `ebnf-lex-comment-char' and `ebnf-lex-eop-char'.
|
|
272 ;;
|
|
273 ;; `iso-ebnf' ebnf2ps recognizes the syntax described in the URL:
|
|
274 ;; `http://www.cl.cam.ac.uk/~mgk25/iso-ebnf.html'
|
|
275 ;; ("International Standard of the ISO EBNF Notation").
|
|
276 ;; The following variables *ONLY* have effect with this
|
|
277 ;; setting:
|
|
278 ;; `ebnf-iso-alternative-p' and `ebnf-iso-normalize-p'.
|
|
279 ;;
|
|
280 ;; `yacc' ebnf2ps recognizes the Yacc/Bison syntax.
|
|
281 ;; The following variable *ONLY* has effect with this
|
|
282 ;; setting:
|
|
283 ;; `ebnf-yac-ignore-error-recovery'.
|
|
284 ;;
|
|
285 ;; Any other value is treated as `ebnf'.
|
|
286 ;;
|
|
287 ;; The default value is `ebnf'.
|
|
288 ;;
|
|
289 ;;
|
|
290 ;; Optimizations
|
|
291 ;; -------------
|
|
292 ;;
|
|
293 ;; The following EBNF optimizations are done:
|
|
294 ;;
|
|
295 ;; [ { A }* ] ==> { A }*
|
|
296 ;; [ { A }+ ] ==> { A }*
|
|
297 ;; [ A ] + ==> { A }*
|
|
298 ;; { A }* + ==> { A }*
|
|
299 ;; { A }+ + ==> { A }+
|
|
300 ;; { A }- ==> { A }+
|
|
301 ;; [ A ]- ==> A
|
|
302 ;; ( A | EMPTY )- ==> A
|
|
303 ;; ( A | B | EMPTY )- ==> A | B
|
|
304 ;; [ A | B ] ==> A | B | EMPTY
|
|
305 ;; n * EMPTY ==> EMPTY
|
|
306 ;; EMPTY + ==> EMPTY
|
|
307 ;; EMPTY / EMPTY ==> EMPTY
|
|
308 ;; EMPTY - A ==> EMPTY
|
|
309 ;;
|
|
310 ;; The following optimizations are done when `ebnf-optimize' is non-nil:
|
|
311 ;;
|
|
312 ;; left recursion:
|
|
313 ;; 1. A = B | A C. ==> A = B {C}*.
|
|
314 ;; 2. A = B | A B. ==> A = {B}+.
|
|
315 ;; 3. A = | A B. ==> A = {B}*.
|
|
316 ;; 4. A = B | A C B. ==> A = {B || C}+.
|
|
317 ;; 5. A = B | D | A C | A E. ==> A = ( B | D ) { C | E }*.
|
|
318 ;;
|
|
319 ;; optional:
|
|
320 ;; 6. A = B | . ==> A = [B].
|
|
321 ;; 7. A = | B . ==> A = [B].
|
|
322 ;;
|
|
323 ;; factoration:
|
|
324 ;; 8. A = B C | B D. ==> A = B (C | D).
|
|
325 ;; 9. A = C B | D B. ==> A = (C | D) B.
|
|
326 ;; 10. A = B C E | B D E. ==> A = B (C | D) E.
|
|
327 ;;
|
|
328 ;; The above optimizations are specially useful when `ebnf-syntax' is `yacc'.
|
|
329 ;;
|
|
330 ;;
|
|
331 ;; Form Feed
|
|
332 ;; ---------
|
|
333 ;;
|
|
334 ;; You may use form feed (^L \014) to force a production to start on a new page,
|
|
335 ;; for example:
|
|
336 ;;
|
|
337 ;; a) A = B | C.
|
|
338 ;; ^L
|
|
339 ;; X = Y | Z.
|
|
340 ;;
|
|
341 ;; b) A = B ^L | C.
|
|
342 ;; X = Y | Z.
|
|
343 ;;
|
|
344 ;; c) A = B ^L^L^L | C.^L
|
|
345 ;; ^L
|
|
346 ;; X = Y | Z.
|
|
347 ;;
|
|
348 ;; In all examples above, only the production X will start on a new page.
|
|
349 ;;
|
|
350 ;;
|
|
351 ;; Actions in Comments
|
|
352 ;; -------------------
|
|
353 ;;
|
|
354 ;; ebnf2ps accepts the following actions in comments:
|
|
355 ;;
|
|
356 ;; ;> the next production starts in the same line as the current one.
|
|
357 ;; It is useful when `ebnf-horizontal-orientation' is nil.
|
|
358 ;;
|
|
359 ;; ;< the next production starts in the next line.
|
|
360 ;; It is useful when `ebnf-horizontal-orientation' is non-nil.
|
|
361 ;;
|
|
362 ;; ;[EPS open a new EPS file. The EPS file name has the form:
|
|
363 ;; <PREFIX><NAME>.eps
|
|
364 ;; where <PREFIX> is given by variable `ebnf-eps-prefix' and <NAME>
|
|
365 ;; is the string given by ;[ action comment, this string is mapped
|
|
366 ;; to form a valid file name (see documentation for
|
|
367 ;; `ebnf-eps-buffer' or `ebnf-eps-region').
|
|
368 ;; It has effect only during `ebnf-eps-buffer' or
|
|
369 ;; `ebnf-eps-region' execution.
|
|
370 ;; It's an error to try to open an already opened EPS file.
|
|
371 ;;
|
|
372 ;; ;]EPS close an opened EPS file.
|
|
373 ;; It has effect only during `ebnf-eps-buffer' or
|
|
374 ;; `ebnf-eps-region' execution.
|
|
375 ;; It's an error to try to close a not opened EPS file.
|
|
376 ;;
|
|
377 ;; So if you have:
|
|
378 ;;
|
|
379 ;; (setq ebnf-horizontal-orientation nil)
|
|
380 ;;
|
|
381 ;; A = t.
|
|
382 ;; C = x.
|
|
383 ;; ;> C and B are drawn in the same line
|
|
384 ;; B = y.
|
|
385 ;; W = v.
|
|
386 ;;
|
|
387 ;; The graphical result is:
|
|
388 ;;
|
|
389 ;; +---+
|
|
390 ;; | A |
|
|
391 ;; +---+
|
|
392 ;;
|
|
393 ;; +---------+ +-----+
|
|
394 ;; | | | |
|
|
395 ;; | C | | |
|
|
396 ;; | | | B |
|
|
397 ;; +---------+ | |
|
|
398 ;; | |
|
|
399 ;; +-----+
|
|
400 ;;
|
|
401 ;; +-----------+
|
|
402 ;; | W |
|
|
403 ;; +-----------+
|
|
404 ;;
|
|
405 ;; Note that if ascending production sort is used, the productions A and B will
|
|
406 ;; be drawn in the same line instead of C and B.
|
|
407 ;;
|
|
408 ;; If consecutive actions occur, only the last one takes effect, so if you have:
|
|
409 ;;
|
|
410 ;; A = X.
|
|
411 ;; ;<
|
|
412 ;; ^L
|
|
413 ;; ;>
|
|
414 ;; B = Y.
|
|
415 ;;
|
|
416 ;; Only the ;> will take effect, that is, A and B will be drawn in the same
|
|
417 ;; line.
|
|
418 ;;
|
|
419 ;; In ISO EBNF the above actions are specified as (*>*), (*<*), (*[EPS*) and
|
|
420 ;; (*]EPS*). The first example above should be written:
|
|
421 ;;
|
|
422 ;; A = t;
|
|
423 ;; C = x;
|
|
424 ;; (*> C and B are drawn in the same line *)
|
|
425 ;; B = y;
|
|
426 ;; W = v;
|
|
427 ;;
|
|
428 ;; For an example of EPS action when executing `ebnf-eps-buffer' or
|
|
429 ;; `ebnf-eps-region':
|
|
430 ;;
|
|
431 ;; Z = B0.
|
|
432 ;; ;[CC
|
|
433 ;; ;[AA
|
|
434 ;; A = B1.
|
|
435 ;; ;[BB
|
|
436 ;; C = B2.
|
|
437 ;; ;]AA
|
|
438 ;; B = B3.
|
|
439 ;; ;]BB
|
|
440 ;; ;]CC
|
|
441 ;; D = B4.
|
|
442 ;; E = B5.
|
|
443 ;; ;[CC
|
|
444 ;; F = B6.
|
|
445 ;; ;]CC
|
|
446 ;; G = B7.
|
|
447 ;;
|
|
448 ;; The following table summarizes the results:
|
|
449 ;;
|
|
450 ;; EPS FILE NAME NO SORT ASCENDING SORT DESCENDING SORT
|
|
451 ;; ebnf--AA.eps A C A C C A
|
|
452 ;; ebnf--BB.eps C B B C C B
|
|
453 ;; ebnf--CC.eps A C B F A B C F F C B A
|
|
454 ;; ebnf--D.eps D D D
|
|
455 ;; ebnf--E.eps E E E
|
|
456 ;; ebnf--G.eps G G G
|
|
457 ;; ebnf--Z.eps Z Z Z
|
|
458 ;;
|
|
459 ;; As you can see if EPS actions is not used, each single production is
|
|
460 ;; generated per EPS file. To avoid overriding EPS files, use names in ;[ that
|
|
461 ;; it's not an existing production name.
|
|
462 ;;
|
|
463 ;; In the following case:
|
|
464 ;;
|
|
465 ;; A = B0.
|
|
466 ;; ;[AA
|
|
467 ;; A = B1.
|
|
468 ;; ;[BB
|
|
469 ;; A = B2.
|
|
470 ;;
|
|
471 ;; The production A is generated in both files ebnf--AA.eps and ebnf--BB.eps.
|
|
472 ;;
|
|
473 ;;
|
|
474 ;; Utilities
|
|
475 ;; ---------
|
|
476 ;;
|
|
477 ;; Some tools are provided to help you.
|
|
478 ;;
|
|
479 ;; `ebnf-setup' returns the current setup.
|
|
480 ;;
|
|
481 ;; `ebnf-syntax-buffer' does a syntatic analysis of your EBNF in the current
|
|
482 ;; buffer.
|
|
483 ;;
|
|
484 ;; `ebnf-syntax-region' does a syntatic analysis of your EBNF in the current
|
|
485 ;; region.
|
|
486 ;;
|
|
487 ;; `ebnf-customize' activates a customization buffer for ebnf2ps options.
|
|
488 ;;
|
|
489 ;; `ebnf-syntax-buffer', `ebnf-syntax-region' and `ebnf-customize' can be bound
|
|
490 ;; to keys in the same way as `ebnf-' commands.
|
|
491 ;;
|
|
492 ;;
|
|
493 ;; Hooks
|
|
494 ;; -----
|
|
495 ;;
|
|
496 ;; ebn2ps has the following hook variables:
|
|
497 ;;
|
|
498 ;; `ebnf-hook'
|
|
499 ;; It is evaluated once before any ebnf2ps process.
|
|
500 ;;
|
|
501 ;; `ebnf-production-hook'
|
|
502 ;; It is evaluated on each beginning of production.
|
|
503 ;;
|
|
504 ;; `ebnf-page-hook'
|
|
505 ;; It is evaluated on each beginning of page.
|
|
506 ;;
|
|
507 ;;
|
|
508 ;; Options
|
|
509 ;; -------
|
|
510 ;;
|
|
511 ;; Below it's shown a brief description of ebnf2ps options, please, see the
|
|
512 ;; options declaration in the code for a long documentation.
|
|
513 ;;
|
|
514 ;; `ebnf-horizontal-orientation' Non-nil means productions are drawn
|
|
515 ;; horizontally.
|
|
516 ;;
|
|
517 ;; `ebnf-horizontal-max-height' Non-nil means to use maximum production
|
|
518 ;; height in horizontal orientation.
|
|
519 ;;
|
|
520 ;; `ebnf-production-horizontal-space' Specify horizontal space in points
|
|
521 ;; between productions.
|
|
522 ;;
|
|
523 ;; `ebnf-production-vertical-space' Specify vertical space in points between
|
|
524 ;; productions.
|
|
525 ;;
|
|
526 ;; `ebnf-justify-sequence' Specify justification of terms in a
|
|
527 ;; sequence inside alternatives.
|
|
528 ;;
|
|
529 ;; `ebnf-terminal-regexp' Specify how it's a terminal name.
|
|
530 ;;
|
|
531 ;; `ebnf-case-fold-search' Non-nil means ignore case on matching.
|
|
532 ;;
|
|
533 ;; `ebnf-terminal-font' Specify terminal font.
|
|
534 ;;
|
|
535 ;; `ebnf-terminal-shape' Specify terminal box shape.
|
|
536 ;;
|
|
537 ;; `ebnf-terminal-shadow' Non-nil means terminal box will have a
|
|
538 ;; shadow.
|
|
539 ;;
|
|
540 ;; `ebnf-terminal-border-width' Specify border width for terminal box.
|
|
541 ;;
|
|
542 ;; `ebnf-terminal-border-color' Specify border color for terminal box.
|
|
543 ;;
|
|
544 ;; `ebnf-sort-production' Specify how productions are sorted.
|
|
545 ;;
|
|
546 ;; `ebnf-production-font' Specify production font.
|
|
547 ;;
|
|
548 ;; `ebnf-non-terminal-font' Specify non-terminal font.
|
|
549 ;;
|
|
550 ;; `ebnf-non-terminal-shape' Specify non-terminal box shape.
|
|
551 ;;
|
|
552 ;; `ebnf-non-terminal-shadow' Non-nil means non-terminal box will have
|
|
553 ;; a shadow.
|
|
554 ;;
|
|
555 ;; `ebnf-non-terminal-border-width' Specify border width for non-terminal
|
|
556 ;; box.
|
|
557 ;;
|
|
558 ;; `ebnf-non-terminal-border-color' Specify border color for non-terminal
|
|
559 ;; box.
|
|
560 ;;
|
|
561 ;; `ebnf-special-font' Specify special font.
|
|
562 ;;
|
|
563 ;; `ebnf-special-shape' Specify special box shape.
|
|
564 ;;
|
|
565 ;; `ebnf-special-shadow' Non-nil means special box will have a
|
|
566 ;; shadow.
|
|
567 ;;
|
|
568 ;; `ebnf-special-border-width' Specify border width for special box.
|
|
569 ;;
|
|
570 ;; `ebnf-special-border-color' Specify border color for special box.
|
|
571 ;;
|
|
572 ;; `ebnf-except-font' Specify except font.
|
|
573 ;;
|
|
574 ;; `ebnf-except-shape' Specify except box shape.
|
|
575 ;;
|
|
576 ;; `ebnf-except-shadow' Non-nil means except box will have a
|
|
577 ;; shadow.
|
|
578 ;;
|
|
579 ;; `ebnf-except-border-width' Specify border width for except box.
|
|
580 ;;
|
|
581 ;; `ebnf-except-border-color' Specify border color for except box.
|
|
582 ;;
|
|
583 ;; `ebnf-repeat-font' Specify repeat font.
|
|
584 ;;
|
|
585 ;; `ebnf-repeat-shape' Specify repeat box shape.
|
|
586 ;;
|
|
587 ;; `ebnf-repeat-shadow' Non-nil means repeat box will have a
|
|
588 ;; shadow.
|
|
589 ;;
|
|
590 ;; `ebnf-repeat-border-width' Specify border width for repeat box.
|
|
591 ;;
|
|
592 ;; `ebnf-repeat-border-color' Specify border color for repeat box.
|
|
593 ;;
|
|
594 ;; `ebnf-entry-percentage' Specify entry height on alternatives.
|
|
595 ;;
|
|
596 ;; `ebnf-arrow-shape' Specify the arrow shape.
|
|
597 ;;
|
|
598 ;; `ebnf-chart-shape' Specify chart flow shape.
|
|
599 ;;
|
|
600 ;; `ebnf-color-p' Non-nil means use color.
|
|
601 ;;
|
|
602 ;; `ebnf-line-width' Specify flow line width.
|
|
603 ;;
|
|
604 ;; `ebnf-line-color' Specify flow line color.
|
|
605 ;;
|
|
606 ;; `ebnf-user-arrow' Specify a user arrow shape (a PostScript
|
|
607 ;; code).
|
|
608 ;;
|
|
609 ;; `ebnf-debug-ps' Non-nil means to generate PostScript
|
|
610 ;; debug procedures.
|
|
611 ;;
|
|
612 ;; `ebnf-lex-comment-char' Specify the line comment character.
|
|
613 ;;
|
|
614 ;; `ebnf-lex-eop-char' Specify the end of production character.
|
|
615 ;;
|
|
616 ;; `ebnf-syntax' Specify syntax to be recognized.
|
|
617 ;;
|
|
618 ;; `ebnf-iso-alternative-p' Non-nil means use alternative ISO EBNF.
|
|
619 ;;
|
|
620 ;; `ebnf-iso-normalize-p' Non-nil means normalize ISO EBNF syntax
|
|
621 ;; names.
|
|
622 ;;
|
|
623 ;; `ebnf-default-width' Specify additional border width over
|
|
624 ;; default terminal, non-terminal or
|
|
625 ;; special.
|
|
626 ;;
|
|
627 ;; `ebnf-eps-prefix' Specify EPS prefix file name.
|
|
628 ;;
|
|
629 ;; `ebnf-use-float-format' Non-nil means use `%f' float format.
|
|
630 ;;
|
|
631 ;; `ebnf-yac-ignore-error-recovery' Non-nil means ignore error recovery.
|
|
632 ;;
|
|
633 ;; `ebnf-ignore-empty-rule' Non-nil means ignore empty rules.
|
|
634 ;;
|
|
635 ;; `ebnf-optimize' Non-nil means optimize syntatic chart of
|
|
636 ;; rules.
|
|
637 ;;
|
|
638 ;; To set the above options you may:
|
|
639 ;;
|
|
640 ;; a) insert the code in your ~/.emacs, like:
|
|
641 ;;
|
|
642 ;; (setq ebnf-terminal-shape 'bevel)
|
|
643 ;;
|
|
644 ;; This way always keep your default settings when you enter a new Emacs
|
|
645 ;; session.
|
|
646 ;;
|
|
647 ;; b) or use `set-variable' in your Emacs session, like:
|
|
648 ;;
|
|
649 ;; M-x set-variable RET ebnf-terminal-shape RET bevel RET
|
|
650 ;;
|
|
651 ;; This way keep your settings only during the current Emacs session.
|
|
652 ;;
|
|
653 ;; c) or use customization, for example:
|
|
654 ;; click on menu-bar *Help* option,
|
|
655 ;; then click on *Customize*,
|
|
656 ;; then click on *Browse Customization Groups*,
|
|
657 ;; expand *PostScript* group,
|
|
658 ;; expand *Ebnf2ps* group
|
|
659 ;; and then customize ebnf2ps options.
|
|
660 ;; Through this way, you may choose if the settings are kept or not when
|
|
661 ;; you leave out the current Emacs session.
|
|
662 ;;
|
|
663 ;; d) or see the option value:
|
|
664 ;;
|
|
665 ;; C-h v ebnf-terminal-shape RET
|
|
666 ;;
|
|
667 ;; and click the *customize* hypertext button.
|
|
668 ;; Through this way, you may choose if the settings are kept or not when
|
|
669 ;; you leave out the current Emacs session.
|
|
670 ;;
|
|
671 ;; e) or invoke:
|
|
672 ;;
|
|
673 ;; M-x ebnf-customize RET
|
|
674 ;;
|
|
675 ;; and then customize ebnf2ps options.
|
|
676 ;; Through this way, you may choose if the settings are kept or not when
|
|
677 ;; you leave out the current Emacs session.
|
|
678 ;;
|
|
679 ;;
|
|
680 ;; Styles
|
|
681 ;; ------
|
|
682 ;;
|
|
683 ;; Sometimes you need to change the EBNF style you are using, for example,
|
|
684 ;; change the shapes and colors. These changes may force you to set some
|
|
685 ;; variables and after use, set back the variables to the old values.
|
|
686 ;;
|
|
687 ;; To help to handle this situation, ebnf2ps has the following commands to
|
|
688 ;; handle styles:
|
|
689 ;;
|
|
690 ;; `ebnf-insert-style' Insert a new style NAME with inheritance INHERITS and
|
|
691 ;; values VALUES.
|
|
692 ;;
|
|
693 ;; `ebnf-merge-style' Merge values of style NAME with style VALUES.
|
|
694 ;;
|
|
695 ;; `ebnf-apply-style' Set STYLE to current style.
|
|
696 ;;
|
|
697 ;; `ebnf-reset-style' Reset current style.
|
|
698 ;;
|
|
699 ;; `ebnf-push-style' Push the current style and set STYLE to current style.
|
|
700 ;;
|
|
701 ;; `ebnf-pop-style' Pop a style and set it to current style.
|
|
702 ;;
|
|
703 ;; These commands helps to put together a lot of variable settings in a group
|
|
704 ;; and name this group. So when you wish to apply these settings it's only
|
|
705 ;; needed to give the name.
|
|
706 ;;
|
|
707 ;; There is also a notion of simple inheritance of style; so if you declare that
|
|
708 ;; a style A inherits from a style B, all settings of B is applied first and
|
|
709 ;; then the settings of A is applied. This is useful when you wish to modify
|
|
710 ;; some aspects of an existing style, but at same time wish to keep it
|
|
711 ;; unmodified.
|
|
712 ;;
|
|
713 ;; See documentation for `ebnf-style-database'.
|
|
714 ;;
|
|
715 ;;
|
|
716 ;; Layout
|
|
717 ;; ------
|
|
718 ;;
|
|
719 ;; Below it is the layout of minimum area to draw each element, and it's used
|
|
720 ;; the following terms:
|
|
721 ;;
|
|
722 ;; font height is given by:
|
|
723 ;; (terminal font height + non-terminal font height) / 2
|
|
724 ;;
|
|
725 ;; entry is the vertical position used to know where it should be
|
|
726 ;; drawn the flow line in the current element.
|
|
727 ;;
|
|
728 ;;
|
|
729 ;; * SPECIAL, TERMINAL and NON-TERMINAL
|
|
730 ;;
|
|
731 ;; +==============+...................................
|
|
732 ;; | | } font height / 2 } entry }
|
|
733 ;; | XXXXXXXX...|....... } }
|
|
734 ;; ====+ XXXXXXXX +==== } text height ...... } height
|
|
735 ;; : | XXXXXXXX...|...:... }
|
|
736 ;; : | : : | : } font height / 2 }
|
|
737 ;; : +==============+...:...............................
|
|
738 ;; : : : : : :
|
|
739 ;; : : : : : :......................
|
|
740 ;; : : : : : } font height }
|
|
741 ;; : : : : :....... }
|
|
742 ;; : : : : } font height / 2 }
|
|
743 ;; : : : :........... }
|
|
744 ;; : : : } text width } width
|
|
745 ;; : : :.................. }
|
|
746 ;; : : } font height / 2 }
|
|
747 ;; : :...................... }
|
|
748 ;; : } font height }
|
|
749 ;; :.............................................
|
|
750 ;;
|
|
751 ;;
|
|
752 ;; * OPTIONAL
|
|
753 ;;
|
|
754 ;; +==========+.....................................
|
|
755 ;; | | } } }
|
|
756 ;; | | } entry } }
|
|
757 ;; | | } } }
|
|
758 ;; ===+===+ +===+===... } element height } height
|
|
759 ;; : \ | | / : } }
|
|
760 ;; : + | | + : } }
|
|
761 ;; : | +==========+.|................. }
|
|
762 ;; : | : : | : } font height }
|
|
763 ;; : +==============+...................................
|
|
764 ;; : : : :
|
|
765 ;; : : : :......................
|
|
766 ;; : : : } font height * 2 }
|
|
767 ;; : : :.......... }
|
|
768 ;; : : } element width } width
|
|
769 ;; : :..................... }
|
|
770 ;; : } font height * 2 }
|
|
771 ;; :...............................................
|
|
772 ;;
|
|
773 ;;
|
|
774 ;; * ALTERNATIVE
|
|
775 ;;
|
|
776 ;; +===+...................................
|
|
777 ;; +==+ A +==+ } A height } }
|
|
778 ;; | +===+..|........ } entry }
|
|
779 ;; + + } font height } }
|
|
780 ;; / +===+...\....... } }
|
|
781 ;; ===+====+ B +====+=== } B height ..... } height
|
|
782 ;; : \ +===+.../....... }
|
|
783 ;; : + + : } font height }
|
|
784 ;; : | +===+..|........ }
|
|
785 ;; : +==+ C +==+ : } C height }
|
|
786 ;; : : +===+...................................
|
|
787 ;; : : : :
|
|
788 ;; : : : :......................
|
|
789 ;; : : : } font height * 2 }
|
|
790 ;; : : :......... }
|
|
791 ;; : : } max width } width
|
|
792 ;; : :................. }
|
|
793 ;; : } font height * 2 }
|
|
794 ;; :..........................................
|
|
795 ;;
|
|
796 ;; NOTES:
|
|
797 ;; 1. An empty alternative has zero of height.
|
|
798 ;;
|
|
799 ;; 2. The variable `ebnf-entry-percentage' is used to determine the
|
|
800 ;; entry point.
|
|
801 ;;
|
|
802 ;;
|
|
803 ;; * ZERO OR MORE
|
|
804 ;;
|
|
805 ;; +===========+...............................
|
|
806 ;; +=+ separator +=+ } separator height }
|
|
807 ;; / +===========+..\........ }
|
|
808 ;; + + } }
|
|
809 ;; | | } font height }
|
|
810 ;; + + } }
|
|
811 ;; \ +===========+../........ } height = entry
|
|
812 ;; +=+ element +=+ } element height }
|
|
813 ;; /: +===========+..\........ }
|
|
814 ;; + : : + } }
|
|
815 ;; + : : + } font height }
|
|
816 ;; / : : \ } }
|
|
817 ;; ==+=======================+==.......................
|
|
818 ;; : : : :
|
|
819 ;; : : : :.......................
|
|
820 ;; : : : } font height * 2 }
|
|
821 ;; : : :......... }
|
|
822 ;; : : } max width } width
|
|
823 ;; : :......................... }
|
|
824 ;; : } font height * 2 }
|
|
825 ;; :...................................................
|
|
826 ;;
|
|
827 ;;
|
|
828 ;; * ONE OR MORE
|
|
829 ;;
|
|
830 ;; +===========+......................................
|
|
831 ;; +=+ separator +=+ } separator height } }
|
|
832 ;; / +===========+..\...... } }
|
|
833 ;; + + } } entry }
|
|
834 ;; | | } font height } } height
|
|
835 ;; + + } } }
|
|
836 ;; \ +===========+../...... } }
|
|
837 ;; ===+=+ element +=+=== } element height .... }
|
|
838 ;; : : +===========+......................................
|
|
839 ;; : : : :
|
|
840 ;; : : : :........................
|
|
841 ;; : : : } font height * 2 }
|
|
842 ;; : : :....... }
|
|
843 ;; : : } max width } width
|
|
844 ;; : :....................... }
|
|
845 ;; : } font height * 2 }
|
|
846 ;; :..............................................
|
|
847 ;;
|
|
848 ;;
|
|
849 ;; * PRODUCTION
|
|
850 ;;
|
|
851 ;; XXXXXX:......................................
|
|
852 ;; XXXXXX: } production font height }
|
|
853 ;; XXXXXX:............ }
|
|
854 ;; } font height }
|
|
855 ;; +======+....... } height = entry
|
|
856 ;; | | } }
|
|
857 ;; ====+ +==== } element height }
|
|
858 ;; : | | : } }
|
|
859 ;; : +======+.................................
|
|
860 ;; : : : :
|
|
861 ;; : : : :......................
|
|
862 ;; : : : } font height * 2 }
|
|
863 ;; : : :....... }
|
|
864 ;; : : } element width } width
|
|
865 ;; : :.............. }
|
|
866 ;; : } font height * 2 }
|
|
867 ;; :.....................................
|
|
868 ;;
|
|
869 ;;
|
|
870 ;; * REPEAT
|
|
871 ;;
|
|
872 ;; +================+...................................
|
|
873 ;; | | } font height / 2 } entry }
|
|
874 ;; | +===+...|....... } }
|
|
875 ;; ====+ N * | X | +==== } X height ......... } height
|
|
876 ;; : | : : +===+...|...:... }
|
|
877 ;; : | : : : : | : } font height / 2 }
|
|
878 ;; : +================+...:...............................
|
|
879 ;; : : : : : : : :
|
|
880 ;; : : : : : : : :......................
|
|
881 ;; : : : : : : : } font height }
|
|
882 ;; : : : : : : :....... }
|
|
883 ;; : : : : : : } font height / 2 }
|
|
884 ;; : : : : : :........... }
|
|
885 ;; : : : : : } X width }
|
|
886 ;; : : : : :............... }
|
|
887 ;; : : : : } font height / 2 } width
|
|
888 ;; : : : :.................. }
|
|
889 ;; : : : } text width }
|
|
890 ;; : : :..................... }
|
|
891 ;; : : } font height / 2 }
|
|
892 ;; : :........................ }
|
|
893 ;; : } font height }
|
|
894 ;; :...............................................
|
|
895 ;;
|
|
896 ;;
|
|
897 ;; * EXCEPT
|
|
898 ;;
|
|
899 ;; +==================+...................................
|
|
900 ;; | | } font height / 2 } entry }
|
|
901 ;; | +===+ +===+...|....... } }
|
|
902 ;; ====+ | X | - | y | +==== } max height ....... } height
|
|
903 ;; : | +===+ +===+...|...:... }
|
|
904 ;; : | : : : : | : } font height / 2 }
|
|
905 ;; : +==================+...:...............................
|
|
906 ;; : : : : : : : :
|
|
907 ;; : : : : : : : :......................
|
|
908 ;; : : : : : : : } font height }
|
|
909 ;; : : : : : : :....... }
|
|
910 ;; : : : : : : } font height / 2 }
|
|
911 ;; : : : : : :........... }
|
|
912 ;; : : : : : } Y width }
|
|
913 ;; : : : : :............... }
|
|
914 ;; : : : : } font height } width
|
|
915 ;; : : : :................... }
|
|
916 ;; : : : } X width }
|
|
917 ;; : : :....................... }
|
|
918 ;; : : } font height / 2 }
|
|
919 ;; : :.......................... }
|
|
920 ;; : } font height }
|
|
921 ;; :.................................................
|
|
922 ;;
|
|
923 ;; NOTE: If Y element is empty, it's draw nothing at Y place.
|
|
924 ;;
|
|
925 ;;
|
|
926 ;; Internal Structures
|
|
927 ;; -------------------
|
|
928 ;;
|
|
929 ;; ebnf2ps has two passes. The first pass does a lexical and syntatic analysis
|
|
930 ;; of current buffer and generates an intermediate representation. The second
|
|
931 ;; pass uses the intermediate representation to generate the PostScript syntatic
|
|
932 ;; chart.
|
|
933 ;;
|
|
934 ;; The intermediate representation is a list of vectors, the vector element
|
|
935 ;; represents a syntatic chart element. Below is a vector representation for
|
|
936 ;; each syntatic chart element.
|
|
937 ;;
|
|
938 ;; [production WIDTH-FUN DIM-FUN ENTRY HEIGHT WIDTH NAME PRODUCTION ACTION]
|
|
939 ;; [alternative WIDTH-FUN DIM-FUN ENTRY HEIGHT WIDTH LIST]
|
|
940 ;; [sequence WIDTH-FUN DIM-FUN ENTRY HEIGHT WIDTH LIST]
|
|
941 ;; [terminal WIDTH-FUN DIM-FUN ENTRY HEIGHT WIDTH NAME DEFAULT]
|
|
942 ;; [non-terminal WIDTH-FUN DIM-FUN ENTRY HEIGHT WIDTH NAME DEFAULT]
|
|
943 ;; [special WIDTH-FUN DIM-FUN ENTRY HEIGHT WIDTH NAME DEFAULT]
|
|
944 ;; [empty WIDTH-FUN DIM-FUN ENTRY HEIGHT WIDTH]
|
|
945 ;; [optional WIDTH-FUN DIM-FUN ENTRY HEIGHT WIDTH ELEMENT]
|
|
946 ;; [one-or-more WIDTH-FUN DIM-FUN ENTRY HEIGHT WIDTH ELEMENT SEPARATOR]
|
|
947 ;; [zero-or-more WIDTH-FUN DIM-FUN ENTRY HEIGHT WIDTH ELEMENT SEPARATOR]
|
|
948 ;; [repeat WIDTH-FUN DIM-FUN ENTRY HEIGHT WIDTH TIMES ELEMENT]
|
|
949 ;; [except WIDTH-FUN DIM-FUN ENTRY HEIGHT WIDTH ELEMENT ELEMENT]
|
|
950 ;;
|
|
951 ;; The first vector position is a function symbol used to generate PostScript
|
|
952 ;; for this element.
|
|
953 ;; WIDTH-FUN is a function symbol called to adjust the element width.
|
|
954 ;; DIM-FUN is a function symbol called to set the element dimensions.
|
|
955 ;; ENTRY is the element entry point.
|
|
956 ;; HEIGHT and WIDTH are the element height and width, respectively.
|
|
957 ;; NAME is a string that it's the element name.
|
|
958 ;; DEFAULT is a boolean that indicates if it's a `default' element.
|
|
959 ;; PRODUCTION and ELEMENT are vectors that represents sub-elements of current
|
|
960 ;; one.
|
|
961 ;; LIST is a list of vector that represents the list part for alternatives and
|
|
962 ;; sequences.
|
|
963 ;; SEPARATOR is a vector that represents the sub-element used to separate the
|
|
964 ;; list elements.
|
|
965 ;; TIMES is a string representing the number of times that ELEMENT is repeated
|
|
966 ;; on a repeat construction.
|
|
967 ;; ACTION indicates some action that should be done before production is
|
|
968 ;; generated. The current actions are:
|
|
969 ;;
|
|
970 ;; nil no action.
|
|
971 ;;
|
|
972 ;; form-feed current production starts on a new page.
|
|
973 ;;
|
|
974 ;; newline current production starts on next line, this is useful
|
|
975 ;; when `ebnf-horizontal-orientation' is non-nil.
|
|
976 ;;
|
|
977 ;; keep-line current production continues on the current line, this
|
|
978 ;; is useful when `ebnf-horizontal-orientation' is nil.
|
|
979 ;;
|
|
980 ;;
|
|
981 ;; Things To Change
|
|
982 ;; ----------------
|
|
983 ;;
|
|
984 ;; . Handle situations when syntatic chart is out of paper.
|
|
985 ;; . Use other alphabet than ascii.
|
|
986 ;; . Optimizations...
|
|
987 ;;
|
|
988 ;;
|
|
989 ;; Acknowledgements
|
|
990 ;; ----------------
|
|
991 ;;
|
|
992 ;; Thanks to all who emailed comments.
|
|
993 ;;
|
|
994 ;;
|
|
995 ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
996
|
|
997 ;;; code:
|
|
998
|
|
999
|
|
1000 (require 'ps-print)
|
|
1001
|
|
1002 (and (string< ps-print-version "3.05.1")
|
|
1003 (error "`ebnf2ps' requires `ps-print' package version 3.05.1 or later"))
|
|
1004
|
|
1005
|
|
1006 ;; temporary fix for ps-print
|
|
1007 (or (fboundp 'set-buffer-multibyte)
|
|
1008 (defun set-buffer-multibyte (arg)
|
|
1009 (setq enable-multibyte-characters arg)))
|
|
1010
|
|
1011 (or (fboundp 'string-as-unibyte)
|
|
1012 (defun string-as-unibyte (arg) arg))
|
|
1013
|
|
1014 (or (fboundp 'string-as-multibyte)
|
|
1015 (defun string-as-multibyte (arg) arg))
|
|
1016
|
|
1017 (or (fboundp 'charset-after)
|
|
1018 (defun charset-after (&optional arg)
|
|
1019 (char-charset (char-after arg))))
|
|
1020
|
|
1021
|
|
1022 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
1023 ;; User Variables:
|
|
1024
|
|
1025
|
|
1026 ;;; Interface to the command system
|
|
1027
|
|
1028 (defgroup postscript nil
|
|
1029 "PostScript Group"
|
|
1030 :tag "PostScript"
|
|
1031 :group 'emacs)
|
|
1032
|
|
1033
|
|
1034 (defgroup ebnf2ps nil
|
|
1035 "Translate an EBNF to a syntatic chart on PostScript"
|
|
1036 :prefix "ebnf-"
|
|
1037 :group 'wp
|
|
1038 :group 'postscript)
|
|
1039
|
|
1040
|
|
1041 (defgroup ebnf-special nil
|
|
1042 "Special customization"
|
|
1043 :prefix "ebnf-"
|
|
1044 :tag "Special"
|
|
1045 :group 'ebnf2ps)
|
|
1046
|
|
1047
|
|
1048 (defgroup ebnf-except nil
|
|
1049 "Except customization"
|
|
1050 :prefix "ebnf-"
|
|
1051 :tag "Except"
|
|
1052 :group 'ebnf2ps)
|
|
1053
|
|
1054
|
|
1055 (defgroup ebnf-repeat nil
|
|
1056 "Repeat customization"
|
|
1057 :prefix "ebnf-"
|
|
1058 :tag "Repeat"
|
|
1059 :group 'ebnf2ps)
|
|
1060
|
|
1061
|
|
1062 (defgroup ebnf-terminal nil
|
|
1063 "Terminal customization"
|
|
1064 :prefix "ebnf-"
|
|
1065 :tag "Terminal"
|
|
1066 :group 'ebnf2ps)
|
|
1067
|
|
1068
|
|
1069 (defgroup ebnf-non-terminal nil
|
|
1070 "Non-Terminal customization"
|
|
1071 :prefix "ebnf-"
|
|
1072 :tag "Non-Terminal"
|
|
1073 :group 'ebnf2ps)
|
|
1074
|
|
1075
|
|
1076 (defgroup ebnf-production nil
|
|
1077 "Production customization"
|
|
1078 :prefix "ebnf-"
|
|
1079 :tag "Production"
|
|
1080 :group 'ebnf2ps)
|
|
1081
|
|
1082
|
|
1083 (defgroup ebnf-shape nil
|
|
1084 "Shapes customization"
|
|
1085 :prefix "ebnf-"
|
|
1086 :tag "Shape"
|
|
1087 :group 'ebnf2ps)
|
|
1088
|
|
1089
|
|
1090 (defgroup ebnf-displacement nil
|
|
1091 "Displacement customization"
|
|
1092 :prefix "ebnf-"
|
|
1093 :tag "Displacement"
|
|
1094 :group 'ebnf2ps)
|
|
1095
|
|
1096
|
|
1097 (defgroup ebnf-syntatic nil
|
|
1098 "Syntatic customization"
|
|
1099 :prefix "ebnf-"
|
|
1100 :tag "Syntatic"
|
|
1101 :group 'ebnf2ps)
|
|
1102
|
|
1103
|
|
1104 (defgroup ebnf-optimization nil
|
|
1105 "Optimization customization"
|
|
1106 :prefix "ebnf-"
|
|
1107 :tag "Optimization"
|
|
1108 :group 'ebnf2ps)
|
|
1109
|
|
1110
|
|
1111 (defcustom ebnf-horizontal-orientation nil
|
|
1112 "*Non-nil means productions are drawn horizontally."
|
|
1113 :type 'boolean
|
|
1114 :group 'ebnf-displacement)
|
|
1115
|
|
1116
|
|
1117 (defcustom ebnf-horizontal-max-height nil
|
|
1118 "*Non-nil means to use maximum production height in horizontal orientation.
|
|
1119
|
|
1120 It is only used when `ebnf-horizontal-orientation' is non-nil."
|
|
1121 :type 'boolean
|
|
1122 :group 'ebnf-displacement)
|
|
1123
|
|
1124
|
|
1125 (defcustom ebnf-production-horizontal-space 0.0 ; use ebnf2ps default value
|
|
1126 "*Specify horizontal space in points between productions.
|
|
1127
|
|
1128 Value less or equal to zero forces ebnf2ps to set a proper default value."
|
|
1129 :type 'number
|
|
1130 :group 'ebnf-displacement)
|
|
1131
|
|
1132
|
|
1133 (defcustom ebnf-production-vertical-space 0.0 ; use ebnf2ps default value
|
|
1134 "*Specify vertical space in points between productions.
|
|
1135
|
|
1136 Value less or equal to zero forces ebnf2ps to set a proper default value."
|
|
1137 :type 'number
|
|
1138 :group 'ebnf-displacement)
|
|
1139
|
|
1140
|
|
1141 (defcustom ebnf-justify-sequence 'center
|
|
1142 "*Specify justification of terms in a sequence inside alternatives.
|
|
1143
|
|
1144 Valid values are:
|
|
1145
|
|
1146 `left' left justification
|
|
1147 `right' right justification
|
|
1148 any other value centralize"
|
|
1149 :type '(radio :tag "Sequence Justification"
|
|
1150 (const left) (const right) (other :tag "center" center))
|
|
1151 :group 'ebnf-displacement)
|
|
1152
|
|
1153
|
|
1154 (defcustom ebnf-special-font '(7 Courier "Black" "Gray95" bold italic)
|
|
1155 "*Specify special font.
|
|
1156
|
|
1157 See documentation for `ebnf-production-font'."
|
|
1158 :type '(list :tag "Special Font"
|
|
1159 (number :tag "Font Size")
|
|
1160 (symbol :tag "Font Name")
|
|
1161 (choice :tag "Foreground Color"
|
|
1162 (string :tag "Name")
|
|
1163 (other :tag "Default" nil))
|
|
1164 (choice :tag "Background Color"
|
|
1165 (string :tag "Name")
|
|
1166 (other :tag "Default" nil))
|
|
1167 (repeat :tag "Font Attributes" :inline t
|
|
1168 (choice (const bold) (const italic)
|
|
1169 (const underline) (const strikeout)
|
|
1170 (const overline) (const shadow)
|
|
1171 (const box) (const outline))))
|
|
1172 :group 'ebnf-special)
|
|
1173
|
|
1174
|
|
1175 (defcustom ebnf-special-shape 'bevel
|
|
1176 "*Specify special box shape.
|
|
1177
|
|
1178 See documentation for `ebnf-non-terminal-shape'."
|
|
1179 :type '(radio :tag "Special Shape"
|
|
1180 (const miter) (const round) (const bevel))
|
|
1181 :group 'ebnf-special)
|
|
1182
|
|
1183
|
|
1184 (defcustom ebnf-special-shadow nil
|
|
1185 "*Non-nil means special box will have a shadow."
|
|
1186 :type 'boolean
|
|
1187 :group 'ebnf-special)
|
|
1188
|
|
1189
|
|
1190 (defcustom ebnf-special-border-width 0.5
|
|
1191 "*Specify border width for special box."
|
|
1192 :type 'number
|
|
1193 :group 'ebnf-special)
|
|
1194
|
|
1195
|
|
1196 (defcustom ebnf-special-border-color "Black"
|
|
1197 "*Specify border color for special box."
|
|
1198 :type 'string
|
|
1199 :group 'ebnf-special)
|
|
1200
|
|
1201
|
|
1202 (defcustom ebnf-except-font '(7 Courier "Black" "Gray90" bold italic)
|
|
1203 "*Specify except font.
|
|
1204
|
|
1205 See documentation for `ebnf-production-font'."
|
|
1206 :type '(list :tag "Except Font"
|
|
1207 (number :tag "Font Size")
|
|
1208 (symbol :tag "Font Name")
|
|
1209 (choice :tag "Foreground Color"
|
|
1210 (string :tag "Name")
|
|
1211 (other :tag "Default" nil))
|
|
1212 (choice :tag "Background Color"
|
|
1213 (string :tag "Name")
|
|
1214 (other :tag "Default" nil))
|
|
1215 (repeat :tag "Font Attributes" :inline t
|
|
1216 (choice (const bold) (const italic)
|
|
1217 (const underline) (const strikeout)
|
|
1218 (const overline) (const shadow)
|
|
1219 (const box) (const outline))))
|
|
1220 :group 'ebnf-except)
|
|
1221
|
|
1222
|
|
1223 (defcustom ebnf-except-shape 'bevel
|
|
1224 "*Specify except box shape.
|
|
1225
|
|
1226 See documentation for `ebnf-non-terminal-shape'."
|
|
1227 :type '(radio :tag "Except Shape"
|
|
1228 (const miter) (const round) (const bevel))
|
|
1229 :group 'ebnf-except)
|
|
1230
|
|
1231
|
|
1232 (defcustom ebnf-except-shadow nil
|
|
1233 "*Non-nil means except box will have a shadow."
|
|
1234 :type 'boolean
|
|
1235 :group 'ebnf-except)
|
|
1236
|
|
1237
|
|
1238 (defcustom ebnf-except-border-width 0.25
|
|
1239 "*Specify border width for except box."
|
|
1240 :type 'number
|
|
1241 :group 'ebnf-except)
|
|
1242
|
|
1243
|
|
1244 (defcustom ebnf-except-border-color "Black"
|
|
1245 "*Specify border color for except box."
|
|
1246 :type 'string
|
|
1247 :group 'ebnf-except)
|
|
1248
|
|
1249
|
|
1250 (defcustom ebnf-repeat-font '(7 Courier "Black" "Gray85" bold italic)
|
|
1251 "*Specify repeat font.
|
|
1252
|
|
1253 See documentation for `ebnf-production-font'."
|
|
1254 :type '(list :tag "Repeat Font"
|
|
1255 (number :tag "Font Size")
|
|
1256 (symbol :tag "Font Name")
|
|
1257 (choice :tag "Foreground Color"
|
|
1258 (string :tag "Name")
|
|
1259 (other :tag "Default" nil))
|
|
1260 (choice :tag "Background Color"
|
|
1261 (string :tag "Name")
|
|
1262 (other :tag "Default" nil))
|
|
1263 (repeat :tag "Font Attributes" :inline t
|
|
1264 (choice (const bold) (const italic)
|
|
1265 (const underline) (const strikeout)
|
|
1266 (const overline) (const shadow)
|
|
1267 (const box) (const outline))))
|
|
1268 :group 'ebnf-repeat)
|
|
1269
|
|
1270
|
|
1271 (defcustom ebnf-repeat-shape 'bevel
|
|
1272 "*Specify repeat box shape.
|
|
1273
|
|
1274 See documentation for `ebnf-non-terminal-shape'."
|
|
1275 :type '(radio :tag "Repeat Shape"
|
|
1276 (const miter) (const round) (const bevel))
|
|
1277 :group 'ebnf-repeat)
|
|
1278
|
|
1279
|
|
1280 (defcustom ebnf-repeat-shadow nil
|
|
1281 "*Non-nil means repeat box will have a shadow."
|
|
1282 :type 'boolean
|
|
1283 :group 'ebnf-repeat)
|
|
1284
|
|
1285
|
|
1286 (defcustom ebnf-repeat-border-width 0.0
|
|
1287 "*Specify border width for repeat box."
|
|
1288 :type 'number
|
|
1289 :group 'ebnf-repeat)
|
|
1290
|
|
1291
|
|
1292 (defcustom ebnf-repeat-border-color "Black"
|
|
1293 "*Specify border color for repeat box."
|
|
1294 :type 'string
|
|
1295 :group 'ebnf-repeat)
|
|
1296
|
|
1297
|
|
1298 (defcustom ebnf-terminal-font '(7 Courier "Black" "White")
|
|
1299 "*Specify terminal font.
|
|
1300
|
|
1301 See documentation for `ebnf-production-font'."
|
|
1302 :type '(list :tag "Terminal Font"
|
|
1303 (number :tag "Font Size")
|
|
1304 (symbol :tag "Font Name")
|
|
1305 (choice :tag "Foreground Color"
|
|
1306 (string :tag "Name")
|
|
1307 (other :tag "Default" nil))
|
|
1308 (choice :tag "Background Color"
|
|
1309 (string :tag "Name")
|
|
1310 (other :tag "Default" nil))
|
|
1311 (repeat :tag "Font Attributes" :inline t
|
|
1312 (choice (const bold) (const italic)
|
|
1313 (const underline) (const strikeout)
|
|
1314 (const overline) (const shadow)
|
|
1315 (const box) (const outline))))
|
|
1316 :group 'ebnf-terminal)
|
|
1317
|
|
1318
|
|
1319 (defcustom ebnf-terminal-shape 'miter
|
|
1320 "*Specify terminal box shape.
|
|
1321
|
|
1322 See documentation for `ebnf-non-terminal-shape'."
|
|
1323 :type '(radio :tag "Terminal Shape"
|
|
1324 (const miter) (const round) (const bevel))
|
|
1325 :group 'ebnf-terminal)
|
|
1326
|
|
1327
|
|
1328 (defcustom ebnf-terminal-shadow nil
|
|
1329 "*Non-nil means terminal box will have a shadow."
|
|
1330 :type 'boolean
|
|
1331 :group 'ebnf-terminal)
|
|
1332
|
|
1333
|
|
1334 (defcustom ebnf-terminal-border-width 1.0
|
|
1335 "*Specify border width for terminal box."
|
|
1336 :type 'number
|
|
1337 :group 'ebnf-terminal)
|
|
1338
|
|
1339
|
|
1340 (defcustom ebnf-terminal-border-color "Black"
|
|
1341 "*Specify border color for terminal box."
|
|
1342 :type 'string
|
|
1343 :group 'ebnf-terminal)
|
|
1344
|
|
1345
|
|
1346 (defcustom ebnf-sort-production nil
|
|
1347 "*Specify how productions are sorted.
|
|
1348
|
|
1349 Valid values are:
|
|
1350
|
|
1351 nil don't sort productions.
|
|
1352 `ascending' ascending sort.
|
|
1353 any other value descending sort."
|
|
1354 :type '(radio :tag "Production Sort"
|
|
1355 (const :tag "Ascending" ascending)
|
|
1356 (const :tag "Descending" descending)
|
|
1357 (other :tag "No Sort" nil))
|
|
1358 :group 'ebnf-production)
|
|
1359
|
|
1360
|
|
1361 (defcustom ebnf-production-font '(10 Helvetica "Black" "White" bold)
|
|
1362 "*Specify production header font.
|
|
1363
|
|
1364 It is a list with the following form:
|
|
1365
|
|
1366 (SIZE NAME FOREGROUND BACKGROUND ATTRIBUTE...)
|
|
1367
|
|
1368 Where:
|
|
1369 SIZE is the font size.
|
|
1370 NAME is the font name symbol.
|
|
1371 ATTRIBUTE is one of the following symbols:
|
|
1372 bold - use bold font.
|
|
1373 italic - use italic font.
|
|
1374 underline - put a line under text.
|
|
1375 strikeout - like underline, but the line is in middle of text.
|
|
1376 overline - like underline, but the line is over the text.
|
|
1377 shadow - text will have a shadow.
|
|
1378 box - text will be surrounded by a box.
|
|
1379 outline - print characters as hollow outlines.
|
|
1380 FOREGROUND is a foreground string color name; if it's nil, the default color is
|
|
1381 \"Black\".
|
|
1382 BACKGROUND is a background string color name; if it's nil, the default color is
|
|
1383 \"White\".
|
|
1384
|
|
1385 See `ps-font-info-database' for valid font name."
|
|
1386 :type '(list :tag "Production Font"
|
|
1387 (number :tag "Font Size")
|
|
1388 (symbol :tag "Font Name")
|
|
1389 (choice :tag "Foreground Color"
|
|
1390 (string :tag "Name")
|
|
1391 (other :tag "Default" nil))
|
|
1392 (choice :tag "Background Color"
|
|
1393 (string :tag "Name")
|
|
1394 (other :tag "Default" nil))
|
|
1395 (repeat :tag "Font Attributes" :inline t
|
|
1396 (choice (const bold) (const italic)
|
|
1397 (const underline) (const strikeout)
|
|
1398 (const overline) (const shadow)
|
|
1399 (const box) (const outline))))
|
|
1400 :group 'ebnf-production)
|
|
1401
|
|
1402
|
|
1403 (defcustom ebnf-non-terminal-font '(7 Helvetica "Black" "White")
|
|
1404 "*Specify non-terminal font.
|
|
1405
|
|
1406 See documentation for `ebnf-production-font'."
|
|
1407 :type '(list :tag "Non-Terminal Font"
|
|
1408 (number :tag "Font Size")
|
|
1409 (symbol :tag "Font Name")
|
|
1410 (choice :tag "Foreground Color"
|
|
1411 (string :tag "Name")
|
|
1412 (other :tag "Default" nil))
|
|
1413 (choice :tag "Background Color"
|
|
1414 (string :tag "Name")
|
|
1415 (other :tag "Default" nil))
|
|
1416 (repeat :tag "Font Attributes" :inline t
|
|
1417 (choice (const bold) (const italic)
|
|
1418 (const underline) (const strikeout)
|
|
1419 (const overline) (const shadow)
|
|
1420 (const box) (const outline))))
|
|
1421 :group 'ebnf-non-terminal)
|
|
1422
|
|
1423
|
|
1424 (defcustom ebnf-non-terminal-shape 'round
|
|
1425 "*Specify non-terminal box shape.
|
|
1426
|
|
1427 Valid values are:
|
|
1428
|
|
1429 `miter' +-------+
|
|
1430 | |
|
|
1431 +-------+
|
|
1432
|
|
1433 `round' -------
|
|
1434 ( )
|
|
1435 -------
|
|
1436
|
|
1437 `bevel' /-------\\
|
|
1438 | |
|
|
1439 \\-------/
|
|
1440
|
|
1441 Any other value is treated as `miter'."
|
|
1442 :type '(radio :tag "Non-Terminal Shape"
|
|
1443 (const miter) (const round) (const bevel))
|
|
1444 :group 'ebnf-non-terminal)
|
|
1445
|
|
1446
|
|
1447 (defcustom ebnf-non-terminal-shadow nil
|
|
1448 "*Non-nil means non-terminal box will have a shadow."
|
|
1449 :type 'boolean
|
|
1450 :group 'ebnf-non-terminal)
|
|
1451
|
|
1452
|
|
1453 (defcustom ebnf-non-terminal-border-width 1.0
|
|
1454 "*Specify border width for non-terminal box."
|
|
1455 :type 'number
|
|
1456 :group 'ebnf-non-terminal)
|
|
1457
|
|
1458
|
|
1459 (defcustom ebnf-non-terminal-border-color "Black"
|
|
1460 "*Specify border color for non-terminal box."
|
|
1461 :type 'string
|
|
1462 :group 'ebnf-non-terminal)
|
|
1463
|
|
1464
|
|
1465 (defcustom ebnf-arrow-shape 'hollow
|
|
1466 "*Specify the arrow shape.
|
|
1467
|
|
1468 Valid values are:
|
|
1469
|
|
1470 `none' ======
|
|
1471
|
|
1472 `semi-up' * `transparent' *
|
|
1473 * |*
|
|
1474 =====* | *
|
|
1475 ==+==*
|
|
1476 | *
|
|
1477 |*
|
|
1478 *
|
|
1479
|
|
1480 `semi-down' =====* `hollow' *
|
|
1481 * |*
|
|
1482 * | *
|
|
1483 ==+ *
|
|
1484 | *
|
|
1485 |*
|
|
1486 *
|
|
1487
|
|
1488 `simple' * `full' *
|
|
1489 * |*
|
|
1490 =====* |X*
|
|
1491 * ==+XX*
|
|
1492 * |X*
|
|
1493 |*
|
|
1494 *
|
|
1495
|
|
1496 `user' See also documentation for variable `ebnf-user-arrow'.
|
|
1497
|
|
1498 Any other value is treated as `none'."
|
|
1499 :type '(radio :tag "Arrow Shape"
|
|
1500 (const none) (const semi-up)
|
|
1501 (const semi-down) (const simple)
|
|
1502 (const transparent) (const hollow)
|
|
1503 (const full) (const user))
|
|
1504 :group 'ebnf-shape)
|
|
1505
|
|
1506
|
|
1507 (defcustom ebnf-chart-shape 'round
|
|
1508 "*Specify chart flow shape.
|
|
1509
|
|
1510 See documentation for `ebnf-non-terminal-shape'."
|
|
1511 :type '(radio :tag "Chart Flow Shape"
|
|
1512 (const miter) (const round) (const bevel))
|
|
1513 :group 'ebnf-shape)
|
|
1514
|
|
1515
|
|
1516 (defcustom ebnf-user-arrow nil
|
|
1517 "*Specify a user arrow shape (a PostScript code).
|
|
1518
|
|
1519 PostScript code should draw a right arrow.
|
|
1520
|
|
1521 The anatomy of a right arrow is:
|
|
1522
|
|
1523 ...... Initial position
|
|
1524 :
|
|
1525 : *.................
|
|
1526 : | * } }
|
|
1527 : | * } hT4 }
|
|
1528 v | * } }
|
|
1529 ======+======*... } hT2
|
|
1530 : | *: } }
|
|
1531 : | * : } hT4 }
|
|
1532 : | * : } }
|
|
1533 : *.................
|
|
1534 : : :
|
|
1535 : : :..........
|
|
1536 : : } hT2 }
|
|
1537 : :.......... } hT
|
|
1538 : } hT2 }
|
|
1539 :.......................
|
|
1540
|
|
1541 Where `hT', `hT2' and `hT4' are predefined PostScript variable names that can be
|
|
1542 used to generate your own arrow. As these variables are used along PostScript
|
|
1543 execution, *DON'T* modify the values of them. Instead, copy the values, if you
|
|
1544 need to modify them.
|
|
1545
|
|
1546 The relation between these variables is: hT = 2 * hT2 = 4 * hT4.
|
|
1547
|
|
1548 The variable `ebnf-user-arrow' is only used when `ebnf-arrow-shape' is set to
|
|
1549 symbol `user'.
|
|
1550
|
|
1551 See function `ebnf-user-arrow' for valid values and how values are processed."
|
|
1552 :type '(radio :tag "User Arrow Shape"
|
|
1553 (const nil)
|
|
1554 string
|
|
1555 symbol
|
|
1556 (repeat :tag "List"
|
|
1557 (radio string
|
|
1558 symbol
|
|
1559 sexp)))
|
|
1560 :group 'ebnf-shape)
|
|
1561
|
|
1562
|
|
1563 (defcustom ebnf-syntax 'ebnf
|
|
1564 "*Specify syntax to be recognized.
|
|
1565
|
|
1566 Valid values are:
|
|
1567
|
|
1568 `ebnf' ebnf2ps recognizes the syntax described above.
|
|
1569 The following variables *ONLY* have effect with this
|
|
1570 setting:
|
|
1571 `ebnf-terminal-regexp', `ebnf-case-fold-search',
|
|
1572 `ebnf-lex-comment-char' and `ebnf-lex-eop-char'.
|
|
1573
|
|
1574 `iso-ebnf' ebnf2ps recognizes the syntax described in the URL:
|
|
1575 `http://www.cl.cam.ac.uk/~mgk25/iso-ebnf.html'
|
|
1576 (\"International Standard of the ISO EBNF Notation\").
|
|
1577 The following variables *ONLY* have effect with this
|
|
1578 setting:
|
|
1579 `ebnf-iso-alternative-p' and `ebnf-iso-normalize-p'.
|
|
1580
|
|
1581 `yacc' ebnf2ps recognizes the Yacc/Bison syntax.
|
|
1582 The following variable *ONLY* has effect with this
|
|
1583 setting:
|
|
1584 `ebnf-yac-ignore-error-recovery'.
|
|
1585
|
|
1586 Any other value is treated as `ebnf'."
|
|
1587 :type '(radio :tag "Syntax"
|
|
1588 (const ebnf) (const iso-ebnf) (const yacc))
|
|
1589 :group 'ebnf-syntatic)
|
|
1590
|
|
1591
|
|
1592 (defcustom ebnf-lex-comment-char ?\;
|
|
1593 "*Specify the line comment character.
|
|
1594
|
|
1595 It's used only when `ebnf-syntax' is `ebnf'."
|
|
1596 :type 'character
|
|
1597 :group 'ebnf-syntatic)
|
|
1598
|
|
1599
|
|
1600 (defcustom ebnf-lex-eop-char ?.
|
|
1601 "*Specify the end of production character.
|
|
1602
|
|
1603 It's used only when `ebnf-syntax' is `ebnf'."
|
|
1604 :type 'character
|
|
1605 :group 'ebnf-syntatic)
|
|
1606
|
|
1607
|
|
1608 (defcustom ebnf-terminal-regexp nil
|
|
1609 "*Specify how it's a terminal name.
|
|
1610
|
|
1611 If it's nil, the terminal name must be enclosed by `\"'.
|
|
1612 If it's a string, it should be a regexp that it'll be used to determine a
|
|
1613 terminal name; terminal name may also be enclosed by `\"'.
|
|
1614
|
|
1615 It's used only when `ebnf-syntax' is `ebnf'."
|
|
1616 :type '(radio :tag "Terminal Name"
|
|
1617 (const nil) regexp)
|
|
1618 :group 'ebnf-syntatic)
|
|
1619
|
|
1620
|
|
1621 (defcustom ebnf-case-fold-search nil
|
|
1622 "*Non-nil means ignore case on matching.
|
|
1623
|
|
1624 It's only used when `ebnf-terminal-regexp' is non-nil and when `ebnf-syntax' is
|
|
1625 `ebnf'."
|
|
1626 :type 'boolean
|
|
1627 :group 'ebnf-syntatic)
|
|
1628
|
|
1629
|
|
1630 (defcustom ebnf-iso-alternative-p nil
|
|
1631 "*Non-nil means use alternative ISO EBNF.
|
|
1632
|
|
1633 It's only used when `ebnf-syntax' is `iso-ebnf'.
|
|
1634
|
|
1635 This variable affects the following symbol set:
|
|
1636
|
|
1637 STANDARD ALTERNATIVE
|
|
1638 | ==> / or !
|
|
1639 [ ==> (/
|
|
1640 ] ==> /)
|
|
1641 { ==> (:
|
|
1642 } ==> :)
|
|
1643 ; ==> ."
|
|
1644 :type 'boolean
|
|
1645 :group 'ebnf-syntatic)
|
|
1646
|
|
1647
|
|
1648 (defcustom ebnf-iso-normalize-p nil
|
|
1649 "*Non-nil means normalize ISO EBNF syntax names.
|
|
1650
|
|
1651 Normalize a name means that several contiguous spaces inside name become a
|
|
1652 single space, so \"A B C\" is normalized to \"A B C\".
|
|
1653
|
|
1654 It's only used when `ebnf-syntax' is `iso-ebnf'."
|
|
1655 :type 'boolean
|
|
1656 :group 'ebnf-syntatic)
|
|
1657
|
|
1658
|
|
1659 (defcustom ebnf-eps-prefix "ebnf--"
|
|
1660 "*Specify EPS prefix file name.
|
|
1661
|
|
1662 See `ebnf-eps-buffer' and `ebnf-eps-region' commands."
|
|
1663 :type 'string
|
|
1664 :group 'ebnf2ps)
|
|
1665
|
|
1666
|
|
1667 (defcustom ebnf-entry-percentage 0.5 ; middle
|
|
1668 "*Specify entry height on alternatives.
|
|
1669
|
|
1670 It must be a float between 0.0 (top) and 1.0 (bottom)."
|
|
1671 :type 'number
|
|
1672 :group 'ebnf2ps)
|
|
1673
|
|
1674
|
|
1675 (defcustom ebnf-default-width 0.6
|
|
1676 "*Specify additional border width over default terminal, non-terminal or
|
|
1677 special."
|
|
1678 :type 'number
|
|
1679 :group 'ebnf2ps)
|
|
1680
|
|
1681
|
|
1682 ;; Printing color requires x-color-values.
|
|
1683 (defcustom ebnf-color-p (or (fboundp 'x-color-values) ; Emacs
|
|
1684 (fboundp 'color-instance-rgb-components)) ; XEmacs
|
|
1685 "*Non-nil means use color."
|
|
1686 :type 'boolean
|
|
1687 :group 'ebnf2ps)
|
|
1688
|
|
1689
|
|
1690 (defcustom ebnf-line-width 1.0
|
|
1691 "*Specify flow line width."
|
|
1692 :type 'number
|
|
1693 :group 'ebnf2ps)
|
|
1694
|
|
1695
|
|
1696 (defcustom ebnf-line-color "Black"
|
|
1697 "*Specify flow line color."
|
|
1698 :type 'string
|
|
1699 :group 'ebnf2ps)
|
|
1700
|
|
1701
|
|
1702 (defcustom ebnf-debug-ps nil
|
|
1703 "*Non-nil means to generate PostScript debug procedures.
|
|
1704
|
|
1705 It is intended to help PostScript programmers in debugging."
|
|
1706 :type 'boolean
|
|
1707 :group 'ebnf2ps)
|
|
1708
|
|
1709
|
|
1710 (defcustom ebnf-use-float-format t
|
|
1711 "*Non-nil means use `%f' float format.
|
|
1712
|
|
1713 The advantage of using float format is that ebnf2ps generates a little short
|
|
1714 PostScript file.
|
|
1715
|
|
1716 If it occurs the error message:
|
|
1717
|
|
1718 Invalid format operation %f
|
|
1719
|
|
1720 when executing ebnf2ps, set `ebnf-use-float-format' to nil."
|
|
1721 :type 'boolean
|
|
1722 :group 'ebnf2ps)
|
|
1723
|
|
1724
|
|
1725 (defcustom ebnf-yac-ignore-error-recovery nil
|
|
1726 "*Non-nil means ignore error recovery.
|
|
1727
|
|
1728 It's only used when `ebnf-syntax' is `yacc'."
|
|
1729 :type 'boolean
|
|
1730 :group 'ebnf-syntatic)
|
|
1731
|
|
1732
|
|
1733 (defcustom ebnf-ignore-empty-rule nil
|
|
1734 "*Non-nil means ignore empty rules.
|
|
1735
|
|
1736 It's interesting to set this variable if your Yacc/Bison grammar has a lot of
|
|
1737 middle action rule."
|
|
1738 :type 'boolean
|
|
1739 :group 'ebnf-optimization)
|
|
1740
|
|
1741
|
|
1742 (defcustom ebnf-optimize nil
|
|
1743 "*Non-nil means optimize syntatic chart of rules.
|
|
1744
|
|
1745 The following optimizations are done:
|
|
1746
|
|
1747 left recursion:
|
|
1748 1. A = B | A C. ==> A = B {C}*.
|
|
1749 2. A = B | A B. ==> A = {B}+.
|
|
1750 3. A = | A B. ==> A = {B}*.
|
|
1751 4. A = B | A C B. ==> A = {B || C}+.
|
|
1752 5. A = B | D | A C | A E. ==> A = ( B | D ) { C | E }*.
|
|
1753
|
|
1754 optional:
|
|
1755 6. A = B | . ==> A = [B].
|
|
1756 7. A = | B . ==> A = [B].
|
|
1757
|
|
1758 factoration:
|
|
1759 8. A = B C | B D. ==> A = B (C | D).
|
|
1760 9. A = C B | D B. ==> A = (C | D) B.
|
|
1761 10. A = B C E | B D E. ==> A = B (C | D) E.
|
|
1762
|
|
1763 The above optimizations are specially useful when `ebnf-syntax' is `yacc'."
|
|
1764 :type 'boolean
|
|
1765 :group 'ebnf-optimization)
|
|
1766
|
|
1767
|
|
1768 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
1769 ;; Customization
|
|
1770
|
|
1771
|
|
1772 ;;;###autoload
|
|
1773 (defun ebnf-customize ()
|
|
1774 "Customization for ebnf group."
|
|
1775 (interactive)
|
|
1776 (customize-group 'ebnf2ps))
|
|
1777
|
|
1778
|
|
1779 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
1780 ;; User commands
|
|
1781
|
|
1782
|
|
1783 ;;;###autoload
|
|
1784 (defun ebnf-print-buffer (&optional filename)
|
|
1785 "Generate and print a PostScript syntatic chart image of the buffer.
|
|
1786
|
|
1787 When called with a numeric prefix argument (C-u), prompts the user for
|
|
1788 the name of a file to save the PostScript image in, instead of sending
|
|
1789 it to the printer.
|
|
1790
|
|
1791 More specifically, the FILENAME argument is treated as follows: if it
|
|
1792 is nil, send the image to the printer. If FILENAME is a string, save
|
|
1793 the PostScript image in a file with that name. If FILENAME is a
|
|
1794 number, prompt the user for the name of the file to save in."
|
|
1795 (interactive (list (ps-print-preprint current-prefix-arg)))
|
|
1796 (ebnf-print-region (point-min) (point-max) filename))
|
|
1797
|
|
1798
|
|
1799 ;;;###autoload
|
|
1800 (defun ebnf-print-region (from to &optional filename)
|
|
1801 "Generate and print a PostScript syntatic chart image of the region.
|
|
1802 Like `ebnf-print-buffer', but prints just the current region."
|
|
1803 (interactive (list (point) (mark) (ps-print-preprint current-prefix-arg)))
|
|
1804 (run-hooks 'ebnf-hook)
|
|
1805 (or (ebnf-spool-region from to)
|
|
1806 (ps-do-despool filename)))
|
|
1807
|
|
1808
|
|
1809 ;;;###autoload
|
|
1810 (defun ebnf-spool-buffer ()
|
|
1811 "Generate and spool a PostScript syntatic chart image of the buffer.
|
|
1812 Like `ebnf-print-buffer' except that the PostScript image is saved in a
|
|
1813 local buffer to be sent to the printer later.
|
|
1814
|
|
1815 Use the command `ebnf-despool' to send the spooled images to the printer."
|
|
1816 (interactive)
|
|
1817 (ebnf-spool-region (point-min) (point-max)))
|
|
1818
|
|
1819
|
|
1820 ;;;###autoload
|
|
1821 (defun ebnf-spool-region (from to)
|
|
1822 "Generate a PostScript syntatic chart image of the region and spool locally.
|
|
1823 Like `ebnf-spool-buffer', but spools just the current region.
|
|
1824
|
|
1825 Use the command `ebnf-despool' to send the spooled images to the printer."
|
|
1826 (interactive "r")
|
|
1827 (ebnf-generate-region from to 'ebnf-generate))
|
|
1828
|
|
1829
|
|
1830 ;;;###autoload
|
|
1831 (defun ebnf-eps-buffer ()
|
|
1832 "Generate a PostScript syntatic chart image of the buffer in a EPS file.
|
|
1833
|
|
1834 Indeed, for each production is generated a EPS file.
|
|
1835 The EPS file name has the following form:
|
|
1836
|
|
1837 <PREFIX><PRODUCTION>.eps
|
|
1838
|
|
1839 <PREFIX> is given by variable `ebnf-eps-prefix'.
|
|
1840 The default value is \"ebnf--\".
|
|
1841
|
|
1842 <PRODUCTION> is the production name.
|
|
1843 The production name is mapped to form a valid file name.
|
|
1844 For example, the production name \"A/B + C\" is mapped to
|
|
1845 \"A_B_+_C\" and the EPS file name used is \"ebnf--A_B_+_C.eps\".
|
|
1846
|
|
1847 WARNING: It's *NOT* asked any confirmation to override an existing file."
|
|
1848 (interactive)
|
|
1849 (ebnf-eps-region (point-min) (point-max)))
|
|
1850
|
|
1851
|
|
1852 ;;;###autoload
|
|
1853 (defun ebnf-eps-region (from to)
|
|
1854 "Generate a PostScript syntatic chart image of the region in a EPS file.
|
|
1855
|
|
1856 Indeed, for each production is generated a EPS file.
|
|
1857 The EPS file name has the following form:
|
|
1858
|
|
1859 <PREFIX><PRODUCTION>.eps
|
|
1860
|
|
1861 <PREFIX> is given by variable `ebnf-eps-prefix'.
|
|
1862 The default value is \"ebnf--\".
|
|
1863
|
|
1864 <PRODUCTION> is the production name.
|
|
1865 The production name is mapped to form a valid file name.
|
|
1866 For example, the production name \"A/B + C\" is mapped to
|
|
1867 \"A_B_+_C\" and the EPS file name used is \"ebnf--A_B_+_C.eps\".
|
|
1868
|
|
1869 WARNING: It's *NOT* asked any confirmation to override an existing file."
|
|
1870 (interactive "r")
|
|
1871 (let ((ebnf-eps-executing t))
|
|
1872 (ebnf-generate-region from to 'ebnf-generate-eps)))
|
|
1873
|
|
1874
|
|
1875 ;;;###autoload
|
|
1876 (defalias 'ebnf-despool 'ps-despool)
|
|
1877
|
|
1878
|
|
1879 ;;;###autoload
|
|
1880 (defun ebnf-syntax-buffer ()
|
|
1881 "Does a syntatic analysis of the current buffer."
|
|
1882 (interactive)
|
|
1883 (ebnf-syntax-region (point-min) (point-max)))
|
|
1884
|
|
1885
|
|
1886 ;;;###autoload
|
|
1887 (defun ebnf-syntax-region (from to)
|
|
1888 "Does a syntatic analysis of a region."
|
|
1889 (interactive "r")
|
|
1890 (ebnf-generate-region from to nil))
|
|
1891
|
|
1892
|
|
1893 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
1894 ;; Utilities
|
|
1895
|
|
1896
|
|
1897 ;;;###autoload
|
|
1898 (defun ebnf-setup ()
|
|
1899 "Return the current ebnf2ps setup."
|
|
1900 (format
|
|
1901 "
|
|
1902 \(setq ebnf-special-font %s
|
|
1903 ebnf-special-shape %s
|
|
1904 ebnf-special-shadow %S
|
|
1905 ebnf-special-border-width %S
|
|
1906 ebnf-special-border-color %S
|
|
1907 ebnf-except-font %s
|
|
1908 ebnf-except-shape %s
|
|
1909 ebnf-except-shadow %S
|
|
1910 ebnf-except-border-width %S
|
|
1911 ebnf-except-border-color %S
|
|
1912 ebnf-repeat-font %s
|
|
1913 ebnf-repeat-shape %s
|
|
1914 ebnf-repeat-shadow %S
|
|
1915 ebnf-repeat-border-width %S
|
|
1916 ebnf-repeat-border-color %S
|
|
1917 ebnf-terminal-regexp %S
|
|
1918 ebnf-case-fold-search %S
|
|
1919 ebnf-terminal-font %s
|
|
1920 ebnf-terminal-shape %s
|
|
1921 ebnf-terminal-shadow %S
|
|
1922 ebnf-terminal-border-width %S
|
|
1923 ebnf-terminal-border-color %S
|
|
1924 ebnf-non-terminal-font %s
|
|
1925 ebnf-non-terminal-shape %s
|
|
1926 ebnf-non-terminal-shadow %S
|
|
1927 ebnf-non-terminal-border-width %S
|
|
1928 ebnf-non-terminal-border-color %S
|
|
1929 ebnf-sort-production %s
|
|
1930 ebnf-production-font %s
|
|
1931 ebnf-arrow-shape %s
|
|
1932 ebnf-chart-shape %s
|
|
1933 ebnf-user-arrow %s
|
|
1934 ebnf-horizontal-orientation %S
|
|
1935 ebnf-horizontal-max-height %S
|
|
1936 ebnf-production-horizontal-space %S
|
|
1937 ebnf-production-vertical-space %S
|
|
1938 ebnf-justify-sequence %s
|
|
1939 ebnf-lex-comment-char ?\\%03o
|
|
1940 ebnf-lex-eop-char ?\\%03o
|
|
1941 ebnf-syntax %s
|
|
1942 ebnf-iso-alternative-p %S
|
|
1943 ebnf-iso-normalize-p %S
|
|
1944 ebnf-eps-prefix %S
|
|
1945 ebnf-entry-percentage %S
|
|
1946 ebnf-color-p %S
|
|
1947 ebnf-line-width %S
|
|
1948 ebnf-line-color %S
|
|
1949 ebnf-debug-ps %S
|
|
1950 ebnf-use-float-format %S
|
|
1951 ebnf-yac-ignore-error-recovery %S
|
|
1952 ebnf-ignore-empty-rule %S
|
|
1953 ebnf-optimize %S)
|
|
1954 "
|
|
1955 (ps-print-quote ebnf-special-font)
|
|
1956 (ps-print-quote ebnf-special-shape)
|
|
1957 ebnf-special-shadow
|
|
1958 ebnf-special-border-width
|
|
1959 ebnf-special-border-color
|
|
1960 (ps-print-quote ebnf-except-font)
|
|
1961 (ps-print-quote ebnf-except-shape)
|
|
1962 ebnf-except-shadow
|
|
1963 ebnf-except-border-width
|
|
1964 ebnf-except-border-color
|
|
1965 (ps-print-quote ebnf-repeat-font)
|
|
1966 (ps-print-quote ebnf-repeat-shape)
|
|
1967 ebnf-repeat-shadow
|
|
1968 ebnf-repeat-border-width
|
|
1969 ebnf-repeat-border-color
|
|
1970 ebnf-terminal-regexp
|
|
1971 ebnf-case-fold-search
|
|
1972 (ps-print-quote ebnf-terminal-font)
|
|
1973 (ps-print-quote ebnf-terminal-shape)
|
|
1974 ebnf-terminal-shadow
|
|
1975 ebnf-terminal-border-width
|
|
1976 ebnf-terminal-border-color
|
|
1977 (ps-print-quote ebnf-non-terminal-font)
|
|
1978 (ps-print-quote ebnf-non-terminal-shape)
|
|
1979 ebnf-non-terminal-shadow
|
|
1980 ebnf-non-terminal-border-width
|
|
1981 ebnf-non-terminal-border-color
|
|
1982 (ps-print-quote ebnf-sort-production)
|
|
1983 (ps-print-quote ebnf-production-font)
|
|
1984 (ps-print-quote ebnf-arrow-shape)
|
|
1985 (ps-print-quote ebnf-chart-shape)
|
|
1986 (ps-print-quote ebnf-user-arrow)
|
|
1987 ebnf-horizontal-orientation
|
|
1988 ebnf-horizontal-max-height
|
|
1989 ebnf-production-horizontal-space
|
|
1990 ebnf-production-vertical-space
|
|
1991 (ps-print-quote ebnf-justify-sequence)
|
|
1992 ebnf-lex-comment-char
|
|
1993 ebnf-lex-eop-char
|
|
1994 (ps-print-quote ebnf-syntax)
|
|
1995 ebnf-iso-alternative-p
|
|
1996 ebnf-iso-normalize-p
|
|
1997 ebnf-eps-prefix
|
|
1998 ebnf-entry-percentage
|
|
1999 ebnf-color-p
|
|
2000 ebnf-line-width
|
|
2001 ebnf-line-color
|
|
2002 ebnf-debug-ps
|
|
2003 ebnf-use-float-format
|
|
2004 ebnf-yac-ignore-error-recovery
|
|
2005 ebnf-ignore-empty-rule
|
|
2006 ebnf-optimize))
|
|
2007
|
|
2008
|
|
2009 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
2010 ;; Style variables
|
|
2011
|
|
2012
|
|
2013 (defvar ebnf-stack-style nil
|
|
2014 "Used in functions `ebnf-reset-style', `ebnf-push-style' and
|
|
2015 `ebnf-pop-style'.")
|
|
2016
|
|
2017
|
|
2018 (defvar ebnf-current-style 'default
|
|
2019 "Used in functions `ebnf-apply-style' and `ebnf-push-style'.")
|
|
2020
|
|
2021
|
|
2022 (defconst ebnf-style-custom-list
|
|
2023 '(ebnf-special-font
|
|
2024 ebnf-special-shape
|
|
2025 ebnf-special-shadow
|
|
2026 ebnf-special-border-width
|
|
2027 ebnf-special-border-color
|
|
2028 ebnf-except-font
|
|
2029 ebnf-except-shape
|
|
2030 ebnf-except-shadow
|
|
2031 ebnf-except-border-width
|
|
2032 ebnf-except-border-color
|
|
2033 ebnf-repeat-font
|
|
2034 ebnf-repeat-shape
|
|
2035 ebnf-repeat-shadow
|
|
2036 ebnf-repeat-border-width
|
|
2037 ebnf-repeat-border-color
|
|
2038 ebnf-terminal-regexp
|
|
2039 ebnf-case-fold-search
|
|
2040 ebnf-terminal-font
|
|
2041 ebnf-terminal-shape
|
|
2042 ebnf-terminal-shadow
|
|
2043 ebnf-terminal-border-width
|
|
2044 ebnf-terminal-border-color
|
|
2045 ebnf-non-terminal-font
|
|
2046 ebnf-non-terminal-shape
|
|
2047 ebnf-non-terminal-shadow
|
|
2048 ebnf-non-terminal-border-width
|
|
2049 ebnf-non-terminal-border-color
|
|
2050 ebnf-sort-production
|
|
2051 ebnf-production-font
|
|
2052 ebnf-arrow-shape
|
|
2053 ebnf-chart-shape
|
|
2054 ebnf-user-arrow
|
|
2055 ebnf-horizontal-orientation
|
|
2056 ebnf-horizontal-max-height
|
|
2057 ebnf-production-horizontal-space
|
|
2058 ebnf-production-vertical-space
|
|
2059 ebnf-justify-sequence
|
|
2060 ebnf-lex-comment-char
|
|
2061 ebnf-lex-eop-char
|
|
2062 ebnf-syntax
|
|
2063 ebnf-iso-alternative-p
|
|
2064 ebnf-iso-normalize-p
|
|
2065 ebnf-eps-prefix
|
|
2066 ebnf-entry-percentage
|
|
2067 ebnf-color-p
|
|
2068 ebnf-line-width
|
|
2069 ebnf-line-color
|
|
2070 ebnf-debug-ps
|
|
2071 ebnf-use-float-format
|
|
2072 ebnf-yac-ignore-error-recovery
|
|
2073 ebnf-ignore-empty-rule
|
|
2074 ebnf-optimize)
|
|
2075 "List of valid symbol custom variable.")
|
|
2076
|
|
2077
|
|
2078 (defvar ebnf-style-database
|
|
2079 '(;; EBNF default
|
|
2080 (default
|
|
2081 nil
|
|
2082 (ebnf-special-font . '(7 Courier "Black" "Gray95" bold italic))
|
|
2083 (ebnf-special-shape . 'bevel)
|
|
2084 (ebnf-special-shadow . nil)
|
|
2085 (ebnf-special-border-width . 0.5)
|
|
2086 (ebnf-special-border-color . "Black")
|
|
2087 (ebnf-except-font . '(7 Courier "Black" "Gray90" bold italic))
|
|
2088 (ebnf-except-shape . 'bevel)
|
|
2089 (ebnf-except-shadow . nil)
|
|
2090 (ebnf-except-border-width . 0.25)
|
|
2091 (ebnf-except-border-color . "Black")
|
|
2092 (ebnf-repeat-font . '(7 Courier "Black" "Gray85" bold italic))
|
|
2093 (ebnf-repeat-shape . 'bevel)
|
|
2094 (ebnf-repeat-shadow . nil)
|
|
2095 (ebnf-repeat-border-width . 0.0)
|
|
2096 (ebnf-repeat-border-color . "Black")
|
|
2097 (ebnf-terminal-regexp . nil)
|
|
2098 (ebnf-case-fold-search . nil)
|
|
2099 (ebnf-terminal-font . '(7 Courier "Black" "White"))
|
|
2100 (ebnf-terminal-shape . 'miter)
|
|
2101 (ebnf-terminal-shadow . nil)
|
|
2102 (ebnf-terminal-border-width . 1.0)
|
|
2103 (ebnf-terminal-border-color . "Black")
|
|
2104 (ebnf-non-terminal-font . '(7 Helvetica "Black" "White"))
|
|
2105 (ebnf-non-terminal-shape . 'round)
|
|
2106 (ebnf-non-terminal-shadow . nil)
|
|
2107 (ebnf-non-terminal-border-width . 1.0)
|
|
2108 (ebnf-non-terminal-border-color . "Black")
|
|
2109 (ebnf-sort-production . nil)
|
|
2110 (ebnf-production-font . '(10 Helvetica "Black" "White" bold))
|
|
2111 (ebnf-arrow-shape . 'hollow)
|
|
2112 (ebnf-chart-shape . 'round)
|
|
2113 (ebnf-user-arrow . nil)
|
|
2114 (ebnf-horizontal-orientation . nil)
|
|
2115 (ebnf-horizontal-max-height . nil)
|
|
2116 (ebnf-production-horizontal-space . 0.0)
|
|
2117 (ebnf-production-vertical-space . 0.0)
|
|
2118 (ebnf-justify-sequence . 'center)
|
|
2119 (ebnf-lex-comment-char . ?\;)
|
|
2120 (ebnf-lex-eop-char . ?.)
|
|
2121 (ebnf-syntax . 'ebnf)
|
|
2122 (ebnf-iso-alternative-p . nil)
|
|
2123 (ebnf-iso-normalize-p . nil)
|
|
2124 (ebnf-eps-prefix . "ebnf--")
|
|
2125 (ebnf-entry-percentage . 0.5)
|
|
2126 (ebnf-color-p . (or (fboundp 'x-color-values) ; Emacs
|
|
2127 (fboundp 'color-instance-rgb-components))) ; XEmacs
|
|
2128 (ebnf-line-width . 1.0)
|
|
2129 (ebnf-line-color . "Black")
|
|
2130 (ebnf-debug-ps . nil)
|
|
2131 (ebnf-use-float-format . t)
|
|
2132 (ebnf-yac-ignore-error-recovery . nil)
|
|
2133 (ebnf-ignore-empty-rule . nil)
|
|
2134 (ebnf-optimize . nil))
|
|
2135 ;; Happy EBNF default
|
|
2136 (happy
|
|
2137 default
|
|
2138 (ebnf-justify-sequence . 'left)
|
|
2139 (ebnf-lex-comment-char . ?\#)
|
|
2140 (ebnf-lex-eop-char . ?\;))
|
|
2141 ;; ISO EBNF default
|
|
2142 (iso-ebnf
|
|
2143 default
|
|
2144 (ebnf-syntax . 'iso-ebnf))
|
|
2145 ;; Yacc/Bison default
|
|
2146 (yacc
|
|
2147 default
|
|
2148 (ebnf-syntax . 'yacc))
|
|
2149 )
|
|
2150 "Style database.
|
|
2151
|
|
2152 Each element has the following form:
|
|
2153
|
|
2154 (CUSTOM INHERITS (VAR . VALUE)...)
|
|
2155
|
|
2156 CUSTOM is a symbol name style.
|
|
2157 INHERITS is a symbol name style from which the current style inherits the
|
|
2158 context. If INHERITS is nil, means that there is no inheritance.
|
|
2159 VAR is a valid ebnf2ps symbol custom variable. See `ebnf-style-custom-list' for
|
|
2160 valid symbol variable.
|
|
2161 VALUE is a sexp which it'll be evaluated to set the value to VAR. So, don't
|
|
2162 forget to quote symbols and constant lists. See `default' style for an
|
|
2163 example.
|
|
2164
|
|
2165 Don't handle this variable directly. Use functions `ebnf-insert-style' and
|
|
2166 `ebnf-merge-style'.")
|
|
2167
|
|
2168
|
|
2169 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
2170 ;; Style commands
|
|
2171
|
|
2172
|
|
2173 ;;;###autoload
|
|
2174 (defun ebnf-insert-style (name inherits &rest values)
|
|
2175 "Insert a new style NAME with inheritance INHERITS and values VALUES."
|
|
2176 (interactive)
|
|
2177 (and (assoc name ebnf-style-database)
|
|
2178 (error "Style name already exists: %s" name))
|
|
2179 (or (assoc inherits ebnf-style-database)
|
|
2180 (error "Style inheritance name does'nt exist: %s" inherits))
|
|
2181 (setq ebnf-style-database
|
|
2182 (cons (cons name (cons inherits (ebnf-check-style-values values)))
|
|
2183 ebnf-style-database)))
|
|
2184
|
|
2185
|
|
2186 ;;;###autoload
|
|
2187 (defun ebnf-merge-style (name &rest values)
|
|
2188 "Merge values of style NAME with style VALUES."
|
|
2189 (interactive)
|
|
2190 (let ((style (or (assoc name ebnf-style-database)
|
|
2191 (error "Style name does'nt exist: %s" name)))
|
|
2192 (merge (ebnf-check-style-values values))
|
|
2193 val elt new check)
|
|
2194 ;; modify value of existing variables
|
|
2195 (setq val (nthcdr 2 style))
|
|
2196 (while merge
|
|
2197 (setq check (car merge)
|
|
2198 merge (cdr merge)
|
|
2199 elt (assoc (car check) val))
|
|
2200 (if elt
|
|
2201 (setcdr elt (cdr check))
|
|
2202 (setq new (cons check new))))
|
|
2203 ;; insert new variables
|
|
2204 (nconc style (nreverse new))))
|
|
2205
|
|
2206
|
|
2207 ;;;###autoload
|
|
2208 (defun ebnf-apply-style (style)
|
|
2209 "Set STYLE to current style.
|
|
2210
|
|
2211 It returns the old style symbol."
|
|
2212 (interactive)
|
|
2213 (prog1
|
|
2214 ebnf-current-style
|
|
2215 (and (ebnf-apply-style1 style)
|
|
2216 (setq ebnf-current-style style))))
|
|
2217
|
|
2218
|
|
2219 ;;;###autoload
|
|
2220 (defun ebnf-reset-style (&optional style)
|
|
2221 "Reset current style.
|
|
2222
|
|
2223 It returns the old style symbol."
|
|
2224 (interactive)
|
|
2225 (setq ebnf-stack-style nil)
|
|
2226 (ebnf-apply-style (or style 'default)))
|
|
2227
|
|
2228
|
|
2229 ;;;###autoload
|
|
2230 (defun ebnf-push-style (&optional style)
|
|
2231 "Push the current style and set STYLE to current style.
|
|
2232
|
|
2233 It returns the old style symbol."
|
|
2234 (interactive)
|
|
2235 (prog1
|
|
2236 ebnf-current-style
|
|
2237 (setq ebnf-stack-style (cons ebnf-current-style ebnf-stack-style))
|
|
2238 (and style
|
|
2239 (ebnf-apply-style style))))
|
|
2240
|
|
2241
|
|
2242 ;;;###autoload
|
|
2243 (defun ebnf-pop-style ()
|
|
2244 "Pop a style and set it to current style.
|
|
2245
|
|
2246 It returns the old style symbol."
|
|
2247 (interactive)
|
|
2248 (prog1
|
|
2249 (ebnf-apply-style (car ebnf-stack-style))
|
|
2250 (setq ebnf-stack-style (cdr ebnf-stack-style))))
|
|
2251
|
|
2252
|
|
2253 (defun ebnf-apply-style1 (style)
|
|
2254 (let ((value (cdr (assoc style ebnf-style-database))))
|
|
2255 (prog1
|
|
2256 value
|
|
2257 (and (car value) (ebnf-apply-style1 (car value)))
|
|
2258 (while (setq value (cdr value))
|
|
2259 (set (caar value) (eval (cdar value)))))))
|
|
2260
|
|
2261
|
|
2262 (defun ebnf-check-style-values (values)
|
|
2263 (let (style)
|
|
2264 (while values
|
|
2265 (and (memq (car values) ebnf-style-custom-list)
|
|
2266 (setq style (cons (car values) style)))
|
|
2267 (setq values (cdr values)))
|
|
2268 (nreverse style)))
|
|
2269
|
|
2270
|
|
2271 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
2272 ;; Internal variables
|
|
2273
|
|
2274
|
|
2275 (make-local-hook 'ebnf-hook)
|
|
2276 (make-local-hook 'ebnf-production-hook)
|
|
2277 (make-local-hook 'ebnf-page-hook)
|
|
2278
|
|
2279
|
|
2280 (defvar ebnf-eps-buffer-name " *EPS*")
|
|
2281 (defvar ebnf-parser-func nil)
|
|
2282 (defvar ebnf-eps-executing nil)
|
|
2283 (defvar ebnf-eps-upper-x 0.0)
|
|
2284 (make-variable-buffer-local 'ebnf-eps-upper-x)
|
|
2285 (defvar ebnf-eps-upper-y 0.0)
|
|
2286 (make-variable-buffer-local 'ebnf-eps-upper-y)
|
|
2287 (defvar ebnf-eps-prod-width 0.0)
|
|
2288 (make-variable-buffer-local 'ebnf-eps-prod-width)
|
|
2289 (defvar ebnf-eps-max-height 0.0)
|
|
2290 (make-variable-buffer-local 'ebnf-eps-max-height)
|
|
2291 (defvar ebnf-eps-max-width 0.0)
|
|
2292 (make-variable-buffer-local 'ebnf-eps-max-width)
|
|
2293
|
|
2294
|
|
2295 (defvar ebnf-eps-context nil
|
|
2296 "List of EPS file name during parsing.
|
|
2297
|
|
2298 See section \"Actions in Comments\" in ebnf2ps documentation.")
|
|
2299
|
|
2300
|
|
2301 (defvar ebnf-eps-production-list nil
|
|
2302 "Alist associating production name with EPS file name list.
|
|
2303
|
|
2304 Each element has the following form:
|
|
2305
|
|
2306 (PRODUCTION EPS-FILENAME...)
|
|
2307
|
|
2308 PRODUCTION is the production name.
|
|
2309 EPS-FILENAME is the EPS file name.
|
|
2310
|
|
2311 It's generated during parsing and used during EPS generation.
|
|
2312
|
|
2313 See `ebnf-eps-context' and section \"Actions in Comments\" in ebnf2ps
|
|
2314 documentation.")
|
|
2315
|
|
2316
|
|
2317 (defconst ebnf-arrow-shape-alist
|
|
2318 '((none . 0)
|
|
2319 (semi-up . 1)
|
|
2320 (semi-down . 2)
|
|
2321 (simple . 3)
|
|
2322 (transparent . 4)
|
|
2323 (hollow . 5)
|
|
2324 (full . 6)
|
|
2325 (user . 7))
|
|
2326 "Alist associating values for `ebnf-arrow-shape'.
|
|
2327
|
|
2328 See documentation for `ebnf-arrow-shape'.")
|
|
2329
|
|
2330
|
|
2331 (defconst ebnf-terminal-shape-alist
|
|
2332 '((miter . 0)
|
|
2333 (round . 1)
|
|
2334 (bevel . 2))
|
|
2335 "Alist associating values from `ebnf-terminal-shape' to a bit vector.
|
|
2336
|
|
2337 See documentation for `ebnf-terminal-shape', `ebnf-non-terminal-shape' and
|
|
2338 `ebnf-chart-shape'.")
|
|
2339
|
|
2340
|
|
2341 (defvar ebnf-limit nil)
|
|
2342 (defvar ebnf-action nil)
|
|
2343 (defvar ebnf-action-list nil)
|
|
2344
|
|
2345
|
|
2346 (defvar ebnf-default-p nil)
|
|
2347
|
|
2348
|
|
2349 (defvar ebnf-font-height-P 0)
|
|
2350 (defvar ebnf-font-height-T 0)
|
|
2351 (defvar ebnf-font-height-NT 0)
|
|
2352 (defvar ebnf-font-height-S 0)
|
|
2353 (defvar ebnf-font-height-E 0)
|
|
2354 (defvar ebnf-font-height-R 0)
|
|
2355 (defvar ebnf-font-width-P 0)
|
|
2356 (defvar ebnf-font-width-T 0)
|
|
2357 (defvar ebnf-font-width-NT 0)
|
|
2358 (defvar ebnf-font-width-S 0)
|
|
2359 (defvar ebnf-font-width-E 0)
|
|
2360 (defvar ebnf-font-width-R 0)
|
|
2361 (defvar ebnf-space-T 0)
|
|
2362 (defvar ebnf-space-NT 0)
|
|
2363 (defvar ebnf-space-S 0)
|
|
2364 (defvar ebnf-space-E 0)
|
|
2365 (defvar ebnf-space-R 0)
|
|
2366
|
|
2367
|
|
2368 (defvar ebnf-basic-width 0)
|
|
2369 (defvar ebnf-basic-height 0)
|
|
2370 (defvar ebnf-vertical-space 0)
|
|
2371 (defvar ebnf-horizontal-space 0)
|
|
2372
|
|
2373
|
|
2374 (defvar ebnf-settings nil)
|
|
2375 (defvar ebnf-fonts-required nil)
|
|
2376
|
|
2377
|
|
2378 (defconst ebnf-debug
|
|
2379 "
|
|
2380 % === begin EBNF procedures to help debugging
|
|
2381
|
|
2382 % Mark visually current point: string debug
|
|
2383 /debug
|
|
2384 {/-s- exch def
|
|
2385 currentpoint
|
|
2386 gsave -s- show grestore
|
|
2387 gsave
|
|
2388 20 20 rlineto
|
|
2389 0 -40 rlineto
|
|
2390 -40 40 rlineto
|
|
2391 0 -40 rlineto
|
|
2392 20 20 rlineto
|
|
2393 stroke
|
|
2394 grestore
|
|
2395 moveto
|
|
2396 }def
|
|
2397
|
|
2398 % Show number value: number string debug-number
|
|
2399 /debug-number
|
|
2400 {gsave
|
|
2401 20 0 rmoveto show ([) show 60 string cvs show (]) show
|
|
2402 grestore
|
|
2403 }def
|
|
2404
|
|
2405 % === end EBNF procedures to help debugging
|
|
2406
|
|
2407 "
|
|
2408 "This is intended to help debugging PostScript programming.")
|
|
2409
|
|
2410
|
|
2411 (defconst ebnf-prologue
|
|
2412 "
|
|
2413 % === begin EBNF engine
|
|
2414
|
|
2415 % --- Basic Definitions
|
|
2416
|
|
2417 /fS F
|
|
2418 /SpaceS FontHeight 0.5 mul def
|
|
2419 /HeightS FontHeight FontHeight add def
|
|
2420
|
|
2421 /fE F
|
|
2422 /SpaceE FontHeight 0.5 mul def
|
|
2423 /HeightE FontHeight FontHeight add def
|
|
2424
|
|
2425 /fR F
|
|
2426 /SpaceR FontHeight 0.5 mul def
|
|
2427 /HeightR FontHeight FontHeight add def
|
|
2428
|
|
2429 /fT F
|
|
2430 /SpaceT FontHeight 0.5 mul def
|
|
2431 /HeightT FontHeight FontHeight add def
|
|
2432
|
|
2433 /fNT F
|
|
2434 /SpaceNT FontHeight 0.5 mul def
|
|
2435 /HeightNT FontHeight FontHeight add def
|
|
2436
|
|
2437 /T HeightT HeightNT add 0.5 mul def
|
|
2438 /hT T 0.5 mul def
|
|
2439 /hT2 hT 0.5 mul def
|
|
2440 /hT4 hT 0.25 mul def
|
|
2441
|
|
2442 /Er 0.1 def % Error factor
|
|
2443
|
|
2444
|
|
2445 /c{currentpoint}bind def
|
|
2446 /xyi{/xi c /yi exch def def}bind def
|
|
2447 /xyo{/xo c /yo exch def def}bind def
|
|
2448 /xyp{/xp c /yp exch def def}bind def
|
|
2449 /xyt{/xt c /yt exch def def}bind def
|
|
2450
|
|
2451 % vertical movement: x y height vm
|
|
2452 /vm{add moveto}bind def
|
|
2453
|
|
2454 % horizontal movement: x y width hm
|
|
2455 /hm{3 -1 roll exch add exch moveto}bind def
|
|
2456
|
|
2457 % set color: [R G B] SetRGB
|
|
2458 /SetRGB{aload pop setrgbcolor}bind def
|
|
2459
|
|
2460 % filling gray area: gray-scale FillGray
|
|
2461 /FillGray{gsave setgray fill grestore}bind def
|
|
2462
|
|
2463 % filling color area: [R G B] FillRGB
|
|
2464 /FillRGB{gsave SetRGB fill grestore}bind def
|
|
2465
|
|
2466 /Stroke{LineWidth setlinewidth LineColor SetRGB stroke}bind def
|
|
2467 /StrokeShape{borderwidth setlinewidth bordercolor SetRGB stroke}bind def
|
|
2468 /Gstroke{gsave Stroke grestore}bind def
|
|
2469
|
|
2470 % Empty Line: width EL
|
|
2471 /EL{0 rlineto Gstroke}bind def
|
|
2472
|
|
2473 % --- Arrows
|
|
2474
|
|
2475 /Down{hT2 neg hT4 neg rlineto}bind def
|
|
2476
|
|
2477 /Arrow
|
|
2478 {hT2 neg hT4 rmoveto
|
|
2479 hT2 hT4 neg rlineto
|
|
2480 Down
|
|
2481 }bind def
|
|
2482
|
|
2483 /ArrowPath{c newpath moveto Arrow closepath}bind def
|
|
2484
|
|
2485 %>Right Arrow: RA
|
|
2486 % \\
|
|
2487 % *---+
|
|
2488 % /
|
|
2489 /RA-vector
|
|
2490 [{} % 0 - none
|
|
2491 {hT2 neg hT4 rlineto} % 1 - semi-up
|
|
2492 {Down} % 2 - semi-down
|
|
2493 {Arrow} % 3 - simple
|
|
2494 {Gstroke ArrowPath} % 4 - transparent
|
|
2495 {Gstroke ArrowPath 1 FillGray} % 5 - hollow
|
|
2496 {Gstroke ArrowPath LineColor FillRGB} % 6 - full
|
|
2497 {Gstroke gsave UserArrow grestore} % 7 - user
|
|
2498 ]def
|
|
2499
|
|
2500 /RA
|
|
2501 {hT 0 rlineto
|
|
2502 c
|
|
2503 RA-vector ArrowShape get exec
|
|
2504 Gstroke
|
|
2505 moveto
|
|
2506 }def
|
|
2507
|
|
2508 % rotation DrawArrow
|
|
2509 /DrawArrow
|
|
2510 {gsave
|
|
2511 0 0 translate
|
|
2512 rotate
|
|
2513 RA
|
|
2514 c
|
|
2515 grestore
|
|
2516 rmoveto
|
|
2517 }def
|
|
2518
|
|
2519 %>Left Arrow: LA
|
|
2520 % /
|
|
2521 % +---*
|
|
2522 % \\
|
|
2523 /LA{180 DrawArrow}def
|
|
2524
|
|
2525 %>Up Arrow: UA
|
|
2526 % +
|
|
2527 % /|\\
|
|
2528 % |
|
|
2529 % *
|
|
2530 /UA{90 DrawArrow}def
|
|
2531
|
|
2532 %>Down Arrow: DA
|
|
2533 % *
|
|
2534 % |
|
|
2535 % \\|/
|
|
2536 % +
|
|
2537 /DA{270 DrawArrow}def
|
|
2538
|
|
2539 % --- Corners
|
|
2540
|
|
2541 %>corner Right Descendent: height arrow corner_RD
|
|
2542 % _ | arrow
|
|
2543 % / height > 0 | 0 - none
|
|
2544 % | | 1 - right
|
|
2545 % * ---------- | 2 - left
|
|
2546 % | | 3 - vertical
|
|
2547 % \\ height < 0 |
|
|
2548 % - |
|
|
2549 /cRD0-vector
|
|
2550 [% 0 - none
|
|
2551 {0 h rlineto
|
|
2552 hT 0 rlineto}
|
|
2553 % 1 - right
|
|
2554 {0 h rlineto
|
|
2555 RA}
|
|
2556 % 2 - left
|
|
2557 {hT 0 rmoveto xyi
|
|
2558 LA
|
|
2559 0 h neg rlineto
|
|
2560 xi yi moveto}
|
|
2561 % 3 - vertical
|
|
2562 {hT h rmoveto xyi
|
|
2563 hT neg 0 rlineto
|
|
2564 h 0 gt{DA}{UA}ifelse
|
|
2565 xi yi moveto}
|
|
2566 ]def
|
|
2567
|
|
2568 /cRD-vector
|
|
2569 [{cRD0-vector arrow get exec} % 0 - miter
|
|
2570 {0 0 0 h hT h rcurveto} % 1 - rounded
|
|
2571 {hT h rlineto} % 2 - bevel
|
|
2572 ]def
|
|
2573
|
|
2574 /corner_RD
|
|
2575 {/arrow exch def /h exch def
|
|
2576 cRD-vector ChartShape get exec
|
|
2577 Gstroke
|
|
2578 }def
|
|
2579
|
|
2580 %>corner Right Ascendent: height arrow corner_RA
|
|
2581 % | arrow
|
|
2582 % | height > 0 | 0 - none
|
|
2583 % / | 1 - right
|
|
2584 % *- ---------- | 2 - left
|
|
2585 % \\ | 3 - vertical
|
|
2586 % | height < 0 |
|
|
2587 % |
|
|
2588 /cRA0-vector
|
|
2589 [% 0 - none
|
|
2590 {hT 0 rlineto
|
|
2591 0 h rlineto}
|
|
2592 % 1 - right
|
|
2593 {RA
|
|
2594 0 h rlineto}
|
|
2595 % 2 - left
|
|
2596 {hT h rmoveto xyi
|
|
2597 0 h neg rlineto
|
|
2598 LA
|
|
2599 xi yi moveto}
|
|
2600 % 3 - vertical
|
|
2601 {hT h rmoveto xyi
|
|
2602 h 0 gt{DA}{UA}ifelse
|
|
2603 hT neg 0 rlineto
|
|
2604 xi yi moveto}
|
|
2605 ]def
|
|
2606
|
|
2607 /cRA-vector
|
|
2608 [{cRA0-vector arrow get exec} % 0 - miter
|
|
2609 {0 0 hT 0 hT h rcurveto} % 1 - rounded
|
|
2610 {hT h rlineto} % 2 - bevel
|
|
2611 ]def
|
|
2612
|
|
2613 /corner_RA
|
|
2614 {/arrow exch def /h exch def
|
|
2615 cRA-vector ChartShape get exec
|
|
2616 Gstroke
|
|
2617 }def
|
|
2618
|
|
2619 %>corner Left Descendent: height arrow corner_LD
|
|
2620 % _ | arrow
|
|
2621 % \\ height > 0 | 0 - none
|
|
2622 % | | 1 - right
|
|
2623 % * ---------- | 2 - left
|
|
2624 % | | 3 - vertical
|
|
2625 % / height < 0 |
|
|
2626 % - |
|
|
2627 /cLD0-vector
|
|
2628 [% 0 - none
|
|
2629 {0 h rlineto
|
|
2630 hT neg 0 rlineto}
|
|
2631 % 1 - right
|
|
2632 {hT neg h rmoveto xyi
|
|
2633 RA
|
|
2634 0 h neg rlineto
|
|
2635 xi yi moveto}
|
|
2636 % 2 - left
|
|
2637 {0 h rlineto
|
|
2638 LA}
|
|
2639 % 3 - vertical
|
|
2640 {hT neg h rmoveto xyi
|
|
2641 hT 0 rlineto
|
|
2642 h 0 gt{DA}{UA}ifelse
|
|
2643 xi yi moveto}
|
|
2644 ]def
|
|
2645
|
|
2646 /cLD-vector
|
|
2647 [{cLD0-vector arrow get exec} % 0 - miter
|
|
2648 {0 0 0 h hT neg h rcurveto} % 1 - rounded
|
|
2649 {hT neg h rlineto} % 2 - bevel
|
|
2650 ]def
|
|
2651
|
|
2652 /corner_LD
|
|
2653 {/arrow exch def /h exch def
|
|
2654 cLD-vector ChartShape get exec
|
|
2655 Gstroke
|
|
2656 }def
|
|
2657
|
|
2658 %>corner Left Ascendent: height arrow corner_LA
|
|
2659 % | arrow
|
|
2660 % | height > 0 | 0 - none
|
|
2661 % \\ | 1 - right
|
|
2662 % -* ---------- | 2 - left
|
|
2663 % / | 3 - vertical
|
|
2664 % | height < 0 |
|
|
2665 % |
|
|
2666 /cLA0-vector
|
|
2667 [% 0 - none
|
|
2668 {hT neg 0 rlineto
|
|
2669 0 h rlineto}
|
|
2670 % 1 - right
|
|
2671 {hT neg h rmoveto xyi
|
|
2672 0 h neg rlineto
|
|
2673 RA
|
|
2674 xi yi moveto}
|
|
2675 % 2 - left
|
|
2676 {LA
|
|
2677 0 h rlineto}
|
|
2678 % 3 - vertical
|
|
2679 {hT neg h rmoveto xyi
|
|
2680 h 0 gt{DA}{UA}ifelse
|
|
2681 hT 0 rlineto
|
|
2682 xi yi moveto}
|
|
2683 ]def
|
|
2684
|
|
2685 /cLA-vector
|
|
2686 [{cLA0-vector arrow get exec} % 0 - miter
|
|
2687 {0 0 hT neg 0 hT neg h rcurveto} % 1 - rounded
|
|
2688 {hT neg h rlineto} % 2 - bevel
|
|
2689 ]def
|
|
2690
|
|
2691 /corner_LA
|
|
2692 {/arrow exch def /h exch def
|
|
2693 cLA-vector ChartShape get exec
|
|
2694 Gstroke
|
|
2695 }def
|
|
2696
|
|
2697 % --- Flow Stuff
|
|
2698
|
|
2699 % height prepare_height |- line_height corner_height corner_height
|
|
2700 /prepare_height
|
|
2701 {dup 0 gt
|
|
2702 {T sub hT}
|
|
2703 {T add hT neg}ifelse
|
|
2704 dup
|
|
2705 }def
|
|
2706
|
|
2707 %>Left Alternative: height LAlt
|
|
2708 % _
|
|
2709 % /
|
|
2710 % | height > 0
|
|
2711 % |
|
|
2712 % /
|
|
2713 % *- ----------
|
|
2714 % \\
|
|
2715 % |
|
|
2716 % | height < 0
|
|
2717 % \\
|
|
2718 % -
|
|
2719 /LAlt
|
|
2720 {dup 0 eq
|
|
2721 {T exch rlineto}
|
|
2722 {dup abs T lt
|
|
2723 {0.5 mul dup
|
|
2724 1 corner_RA
|
|
2725 0 corner_RD}
|
|
2726 {prepare_height
|
|
2727 1 corner_RA
|
|
2728 exch 0 exch rlineto
|
|
2729 0 corner_RD
|
|
2730 }ifelse
|
|
2731 }ifelse
|
|
2732 }def
|
|
2733
|
|
2734 %>Left Loop: height LLoop
|
|
2735 % _
|
|
2736 % /
|
|
2737 % | height > 0
|
|
2738 % |
|
|
2739 % \\
|
|
2740 % -* ----------
|
|
2741 % /
|
|
2742 % |
|
|
2743 % | height < 0
|
|
2744 % \\
|
|
2745 % -
|
|
2746 /LLoop
|
|
2747 {prepare_height
|
|
2748 3 corner_LA
|
|
2749 exch 0 exch rlineto
|
|
2750 0 corner_RD
|
|
2751 }def
|
|
2752
|
|
2753 %>Right Alternative: height RAlt
|
|
2754 % _
|
|
2755 % \\
|
|
2756 % | height > 0
|
|
2757 % |
|
|
2758 % \\
|
|
2759 % -* ----------
|
|
2760 % /
|
|
2761 % |
|
|
2762 % | height < 0
|
|
2763 % /
|
|
2764 % -
|
|
2765 /RAlt
|
|
2766 {dup 0 eq
|
|
2767 {T neg exch rlineto}
|
|
2768 {dup abs T lt
|
|
2769 {0.5 mul dup
|
|
2770 1 corner_LA
|
|
2771 0 corner_LD}
|
|
2772 {prepare_height
|
|
2773 1 corner_LA
|
|
2774 exch 0 exch rlineto
|
|
2775 0 corner_LD
|
|
2776 }ifelse
|
|
2777 }ifelse
|
|
2778 }def
|
|
2779
|
|
2780 %>Right Loop: height RLoop
|
|
2781 % _
|
|
2782 % \\
|
|
2783 % | height > 0
|
|
2784 % |
|
|
2785 % /
|
|
2786 % *- ----------
|
|
2787 % \\
|
|
2788 % |
|
|
2789 % | height < 0
|
|
2790 % /
|
|
2791 % -
|
|
2792 /RLoop
|
|
2793 {prepare_height
|
|
2794 1 corner_RA
|
|
2795 exch 0 exch rlineto
|
|
2796 0 corner_LD
|
|
2797 }def
|
|
2798
|
|
2799 % --- Terminal, Non-terminal and Special Basics
|
|
2800
|
|
2801 % string width prepare-width |- string
|
|
2802 /prepare-width
|
|
2803 {/width exch def
|
|
2804 dup stringwidth pop space add space add width exch sub 0.5 mul
|
|
2805 /w exch def
|
|
2806 }def
|
|
2807
|
|
2808 % string width begin-right
|
|
2809 /begin-right
|
|
2810 {xyo
|
|
2811 prepare-width
|
|
2812 w hT sub EL
|
|
2813 RA
|
|
2814 }def
|
|
2815
|
|
2816 % end-right
|
|
2817 /end-right
|
|
2818 {xo width add Er add yo moveto
|
|
2819 w Er add neg EL
|
|
2820 xo yo moveto
|
|
2821 }def
|
|
2822
|
|
2823 % string width begin-left
|
|
2824 /begin-left
|
|
2825 {xyo
|
|
2826 prepare-width
|
|
2827 w EL
|
|
2828 }def
|
|
2829
|
|
2830 % end-left
|
|
2831 /end-left
|
|
2832 {xo width add Er add yo moveto
|
|
2833 hT w sub Er add EL
|
|
2834 LA
|
|
2835 xo yo moveto
|
|
2836 }def
|
|
2837
|
|
2838 /ShapePath-vector
|
|
2839 [% 0 - miter
|
|
2840 {xx yy moveto
|
|
2841 xx YY lineto
|
|
2842 XX YY lineto
|
|
2843 XX yy lineto}
|
|
2844 % 1 - rounded
|
|
2845 {/half YY yy sub 0.5 mul abs def
|
|
2846 xx half add YY moveto
|
|
2847 0 0 half neg 0 half neg half neg rcurveto
|
|
2848 0 0 0 half neg half half neg rcurveto
|
|
2849 XX xx sub abs half sub half sub 0 rlineto
|
|
2850 0 0 half 0 half half rcurveto
|
|
2851 0 0 0 half half neg half rcurveto}
|
|
2852 % 2 - bevel
|
|
2853 {/quarter YY yy sub 0.25 mul abs def
|
|
2854 xx quarter add YY moveto
|
|
2855 quarter neg quarter neg rlineto
|
|
2856 0 quarter quarter add neg rlineto
|
|
2857 quarter quarter neg rlineto
|
|
2858 XX xx sub abs quarter sub quarter sub 0 rlineto
|
|
2859 quarter quarter rlineto
|
|
2860 0 quarter quarter add rlineto
|
|
2861 quarter neg quarter rlineto}
|
|
2862 ]def
|
|
2863
|
|
2864 /doShapePath
|
|
2865 {newpath
|
|
2866 ShapePath-vector shape get exec
|
|
2867 closepath
|
|
2868 }def
|
|
2869
|
|
2870 /doShapeShadow
|
|
2871 {gsave
|
|
2872 Xshadow Xshadow add Xshadow add
|
|
2873 Yshadow Yshadow add Yshadow add translate
|
|
2874 doShapePath
|
|
2875 0.9 FillGray
|
|
2876 grestore
|
|
2877 }def
|
|
2878
|
|
2879 /doShape
|
|
2880 {gsave
|
|
2881 doShapePath
|
|
2882 shapecolor FillRGB
|
|
2883 StrokeShape
|
|
2884 grestore
|
|
2885 }def
|
|
2886
|
|
2887 % string SBound |- string
|
|
2888 /SBound
|
|
2889 {/xx c dup /yy exch def
|
|
2890 FontHeight add /YY exch def def
|
|
2891 dup stringwidth pop xx add /XX exch def
|
|
2892 Effect 8 and 0 ne
|
|
2893 {/yy yy YShadow add def
|
|
2894 /XX XX XShadow add def
|
|
2895 }if
|
|
2896 }def
|
|
2897
|
|
2898 % string SBox
|
|
2899 /SBox
|
|
2900 {gsave
|
|
2901 c space sub moveto
|
|
2902 SBound
|
|
2903 /XX XX space add space add def
|
|
2904 /YY YY space add def
|
|
2905 /yy yy space sub def
|
|
2906 shadow{doShapeShadow}if
|
|
2907 doShape
|
|
2908 space Descent abs rmoveto
|
|
2909 foreground SetRGB S
|
|
2910 grestore
|
|
2911 }def
|
|
2912
|
|
2913 % --- Terminal
|
|
2914
|
|
2915 % TeRminal: string TR
|
|
2916 /TR
|
|
2917 {/Effect EffectT def
|
|
2918 /shape ShapeT def
|
|
2919 /shapecolor BackgroundT def
|
|
2920 /borderwidth BorderWidthT def
|
|
2921 /bordercolor BorderColorT def
|
|
2922 /foreground ForegroundT def
|
|
2923 /shadow ShadowT def
|
|
2924 SBox
|
|
2925 }def
|
|
2926
|
|
2927 %>Right Terminal: string width RT |- x y
|
|
2928 /RT
|
|
2929 {xyt
|
|
2930 /fT F
|
|
2931 /space SpaceT def
|
|
2932 begin-right
|
|
2933 TR
|
|
2934 end-right
|
|
2935 xt yt
|
|
2936 }def
|
|
2937
|
|
2938 %>Left Terminal: string width LT |- x y
|
|
2939 /LT
|
|
2940 {xyt
|
|
2941 /fT F
|
|
2942 /space SpaceT def
|
|
2943 begin-left
|
|
2944 TR
|
|
2945 end-left
|
|
2946 xt yt
|
|
2947 }def
|
|
2948
|
|
2949 %>Right Terminal Default: string width RTD |- x y
|
|
2950 /RTD
|
|
2951 {/-save- BorderWidthT def
|
|
2952 /BorderWidthT BorderWidthT DefaultWidth add def
|
|
2953 RT
|
|
2954 /BorderWidthT -save- def
|
|
2955 }def
|
|
2956
|
|
2957 %>Left Terminal Default: string width LTD |- x y
|
|
2958 /LTD
|
|
2959 {/-save- BorderWidthT def
|
|
2960 /BorderWidthT BorderWidthT DefaultWidth add def
|
|
2961 LT
|
|
2962 /BorderWidthT -save- def
|
|
2963 }def
|
|
2964
|
|
2965 % --- Non-Terminal
|
|
2966
|
|
2967 % Non-Terminal: string NT
|
|
2968 /NT
|
|
2969 {/Effect EffectNT def
|
|
2970 /shape ShapeNT def
|
|
2971 /shapecolor BackgroundNT def
|
|
2972 /borderwidth BorderWidthNT def
|
|
2973 /bordercolor BorderColorNT def
|
|
2974 /foreground ForegroundNT def
|
|
2975 /shadow ShadowNT def
|
|
2976 SBox
|
|
2977 }def
|
|
2978
|
|
2979 %>Right Non-Terminal: string width RNT |- x y
|
|
2980 /RNT
|
|
2981 {xyt
|
|
2982 /fNT F
|
|
2983 /space SpaceNT def
|
|
2984 begin-right
|
|
2985 NT
|
|
2986 end-right
|
|
2987 xt yt
|
|
2988 }def
|
|
2989
|
|
2990 %>Left Non-Terminal: string width LNT |- x y
|
|
2991 /LNT
|
|
2992 {xyt
|
|
2993 /fNT F
|
|
2994 /space SpaceNT def
|
|
2995 begin-left
|
|
2996 NT
|
|
2997 end-left
|
|
2998 xt yt
|
|
2999 }def
|
|
3000
|
|
3001 %>Right Non-Terminal Default: string width RNTD |- x y
|
|
3002 /RNTD
|
|
3003 {/-save- BorderWidthNT def
|
|
3004 /BorderWidthNT BorderWidthNT DefaultWidth add def
|
|
3005 RNT
|
|
3006 /BorderWidthNT -save- def
|
|
3007 }def
|
|
3008
|
|
3009 %>Left Non-Terminal Default: string width LNTD |- x y
|
|
3010 /LNTD
|
|
3011 {/-save- BorderWidthNT def
|
|
3012 /BorderWidthNT BorderWidthNT DefaultWidth add def
|
|
3013 LNT
|
|
3014 /BorderWidthNT -save- def
|
|
3015 }def
|
|
3016
|
|
3017 % --- Special
|
|
3018
|
|
3019 % SPecial: string SP
|
|
3020 /SP
|
|
3021 {/Effect EffectS def
|
|
3022 /shape ShapeS def
|
|
3023 /shapecolor BackgroundS def
|
|
3024 /borderwidth BorderWidthS def
|
|
3025 /bordercolor BorderColorS def
|
|
3026 /foreground ForegroundS def
|
|
3027 /shadow ShadowS def
|
|
3028 SBox
|
|
3029 }def
|
|
3030
|
|
3031 %>Right SPecial: string width RSP |- x y
|
|
3032 /RSP
|
|
3033 {xyt
|
|
3034 /fS F
|
|
3035 /space SpaceS def
|
|
3036 begin-right
|
|
3037 SP
|
|
3038 end-right
|
|
3039 xt yt
|
|
3040 }def
|
|
3041
|
|
3042 %>Left SPecial: string width LSP |- x y
|
|
3043 /LSP
|
|
3044 {xyt
|
|
3045 /fS F
|
|
3046 /space SpaceS def
|
|
3047 begin-left
|
|
3048 SP
|
|
3049 end-left
|
|
3050 xt yt
|
|
3051 }def
|
|
3052
|
|
3053 %>Right SPecial Default: string width RSPD |- x y
|
|
3054 /RSPD
|
|
3055 {/-save- BorderWidthS def
|
|
3056 /BorderWidthS BorderWidthS DefaultWidth add def
|
|
3057 RSP
|
|
3058 /BorderWidthS -save- def
|
|
3059 }def
|
|
3060
|
|
3061 %>Left SPecial Default: string width LSPD |- x y
|
|
3062 /LSPD
|
|
3063 {/-save- BorderWidthS def
|
|
3064 /BorderWidthS BorderWidthS DefaultWidth add def
|
|
3065 LSP
|
|
3066 /BorderWidthS -save- def
|
|
3067 }def
|
|
3068
|
|
3069 % --- Repeat and Except basics
|
|
3070
|
|
3071 /begin-direction
|
|
3072 {/w width rwidth sub 0.5 mul def
|
|
3073 width 0 rmoveto}def
|
|
3074
|
|
3075 /end-direction
|
|
3076 {gsave
|
|
3077 /xx c entry add /YY exch def def
|
|
3078 /yy YY height sub def
|
|
3079 /XX xx rwidth add def
|
|
3080 shadow{doShapeShadow}if
|
|
3081 doShape
|
|
3082 grestore
|
|
3083 }def
|
|
3084
|
|
3085 /right-direction
|
|
3086 {begin-direction
|
|
3087 w neg EL
|
|
3088 xt yt moveto
|
|
3089 w hT sub EL RA
|
|
3090 end-direction
|
|
3091 }def
|
|
3092
|
|
3093 /left-direction
|
|
3094 {begin-direction
|
|
3095 hT w sub EL LA
|
|
3096 xt yt moveto
|
|
3097 w EL
|
|
3098 end-direction
|
|
3099 }def
|
|
3100
|
|
3101 % --- Repeat
|
|
3102
|
|
3103 % entry height width rwidth begin-repeat
|
|
3104 /begin-repeat
|
|
3105 {/rwidth exch def
|
|
3106 /width exch def
|
|
3107 /height exch def
|
|
3108 /entry exch def
|
|
3109 /fR F
|
|
3110 /space SpaceR def
|
|
3111 /Effect EffectR def
|
|
3112 /shape ShapeR def
|
|
3113 /shapecolor BackgroundR def
|
|
3114 /borderwidth BorderWidthR def
|
|
3115 /bordercolor BorderColorR def
|
|
3116 /foreground ForegroundR def
|
|
3117 /shadow ShadowR def
|
|
3118 xyt
|
|
3119 }def
|
|
3120
|
|
3121 % string end-repeat |- x y
|
|
3122 /end-repeat
|
|
3123 {gsave
|
|
3124 space Descent rmoveto
|
|
3125 foreground SetRGB S
|
|
3126 c Descent sub
|
|
3127 grestore
|
|
3128 exch space add exch moveto
|
|
3129 xt yt
|
|
3130 }def
|
|
3131
|
|
3132 %>Right RePeat: string entry height width rwidth RRP |- x y
|
|
3133 /RRP{begin-repeat right-direction end-repeat}def
|
|
3134
|
|
3135 %>Left RePeat: string entry height width rwidth LRP |- x y
|
|
3136 /LRP{begin-repeat left-direction end-repeat}def
|
|
3137
|
|
3138 % --- Except
|
|
3139
|
|
3140 % entry height width rwidth begin-except
|
|
3141 /begin-except
|
|
3142 {/rwidth exch def
|
|
3143 /width exch def
|
|
3144 /height exch def
|
|
3145 /entry exch def
|
|
3146 /fE F
|
|
3147 /space SpaceE def
|
|
3148 /Effect EffectE def
|
|
3149 /shape ShapeE def
|
|
3150 /shapecolor BackgroundE def
|
|
3151 /borderwidth BorderWidthE def
|
|
3152 /bordercolor BorderColorE def
|
|
3153 /foreground ForegroundE def
|
|
3154 /shadow ShadowE def
|
|
3155 xyt
|
|
3156 }def
|
|
3157
|
|
3158 % x-width end-except |- x y
|
|
3159 /end-except
|
|
3160 {gsave
|
|
3161 space space add add Descent rmoveto
|
|
3162 (-) foreground SetRGB S
|
|
3163 grestore
|
|
3164 space 0 rmoveto
|
|
3165 xt yt
|
|
3166 }def
|
|
3167
|
|
3168 %>Right EXcept: x-width entry height width rwidth REX |- x y
|
|
3169 /REX{begin-except right-direction end-except}def
|
|
3170
|
|
3171 %>Left EXcept: x-width entry height width rwidth LEX |- x y
|
|
3172 /LEX{begin-except left-direction end-except}def
|
|
3173
|
|
3174 % --- Sequence
|
|
3175
|
|
3176 %>Beginning Of Sequence: BOS |- x y
|
|
3177 /BOS{currentpoint}bind def
|
|
3178
|
|
3179 %>End Of Sequence: x y x1 y1 EOS |- x y
|
|
3180 /EOS{pop pop}bind def
|
|
3181
|
|
3182 % --- Production
|
|
3183
|
|
3184 %>Beginning Of Production: string width height BOP |- y x
|
|
3185 /BOP
|
|
3186 {xyp
|
|
3187 neg yp add /yw exch def
|
|
3188 xp add T sub /xw exch def
|
|
3189 /Effect EffectP def
|
|
3190 /fP F ForegroundP SetRGB BackgroundP aload pop true BG S
|
|
3191 /Effect 0 def
|
|
3192 ( :) S false BG
|
|
3193 xw yw moveto
|
|
3194 hT EL RA
|
|
3195 xp yw moveto
|
|
3196 T EL
|
|
3197 yp xp
|
|
3198 }def
|
|
3199
|
|
3200 %>End Of Production: y x delta EOP
|
|
3201 /EOPH{add exch moveto}bind def % horizontal
|
|
3202 /EOPV{exch pop sub 0 exch moveto}bind def % vertical
|
|
3203
|
|
3204 % --- Empty Alternative
|
|
3205
|
|
3206 %>Empty Alternative: width EA |- x y
|
|
3207 /EA
|
|
3208 {gsave
|
|
3209 Er add 0 rlineto
|
|
3210 Stroke
|
|
3211 grestore
|
|
3212 c
|
|
3213 }def
|
|
3214
|
|
3215 % --- Alternative
|
|
3216
|
|
3217 %>AlTernative: h1 h2 ... hn n width AT |- x y
|
|
3218 /AT
|
|
3219 {xyo xo add /xw exch def
|
|
3220 xw yo moveto
|
|
3221 Er EL
|
|
3222 {xw yo moveto
|
|
3223 dup RAlt
|
|
3224 xo yo moveto
|
|
3225 LAlt}repeat
|
|
3226 xo yo
|
|
3227 }def
|
|
3228
|
|
3229 % --- Optional
|
|
3230
|
|
3231 %>OPtional: height width OP |- x y
|
|
3232 /OP
|
|
3233 {xyo
|
|
3234 T sub /ow exch def
|
|
3235 ow Er sub 0 rmoveto
|
|
3236 T Er add EL
|
|
3237 neg dup RAlt
|
|
3238 ow T sub neg EL
|
|
3239 xo yo moveto
|
|
3240 LAlt
|
|
3241 xo yo moveto
|
|
3242 T EL
|
|
3243 xo yo
|
|
3244 }def
|
|
3245
|
|
3246 % --- List Flow
|
|
3247
|
|
3248 %>One or More: height width OM |- x y
|
|
3249 /OM
|
|
3250 {xyo
|
|
3251 /ow exch def
|
|
3252 ow Er add 0 rmoveto
|
|
3253 T Er add neg EL
|
|
3254 dup RLoop
|
|
3255 xo T add yo moveto
|
|
3256 LLoop
|
|
3257 xo yo moveto
|
|
3258 T EL
|
|
3259 xo yo
|
|
3260 }def
|
|
3261
|
|
3262 %>Zero or More: h2 h1 width ZM |- x y
|
|
3263 /ZM
|
|
3264 {xyo
|
|
3265 Er add EL
|
|
3266 Er neg 0 rmoveto
|
|
3267 dup RAlt
|
|
3268 exch dup RLoop
|
|
3269 xo yo moveto
|
|
3270 exch dup LAlt
|
|
3271 exch LLoop
|
|
3272 yo add xo T add exch moveto
|
|
3273 xo yo
|
|
3274 }def
|
|
3275
|
|
3276 % === end EBNF engine
|
|
3277
|
|
3278 "
|
|
3279 "EBNF PostScript prologue")
|
|
3280
|
|
3281
|
|
3282 (defconst ebnf-eps-prologue
|
|
3283 "
|
|
3284 /#ebnf2ps#dict 230 dict def
|
|
3285 #ebnf2ps#dict begin
|
|
3286
|
|
3287 % Initiliaze variables to avoid name-conflicting with document variables.
|
|
3288 % This is the case when using `bind' operator.
|
|
3289 /-fillp- 0 def /h 0 def
|
|
3290 /-ox- 0 def /half 0 def
|
|
3291 /-oy- 0 def /height 0 def
|
|
3292 /-save- 0 def /ow 0 def
|
|
3293 /Ascent 0 def /quarter 0 def
|
|
3294 /Descent 0 def /rXX 0 def
|
|
3295 /Effect 0 def /rYY 0 def
|
|
3296 /FontHeight 0 def /rwidth 0 def
|
|
3297 /LineThickness 0 def /rxx 0 def
|
|
3298 /OverlinePosition 0 def /ryy 0 def
|
|
3299 /SpaceBackground 0 def /shadow 0 def
|
|
3300 /StrikeoutPosition 0 def /shape 0 def
|
|
3301 /UnderlinePosition 0 def /shapecolor 0 def
|
|
3302 /XBox 0 def /space 0 def
|
|
3303 /XX 0 def /st 1 string def
|
|
3304 /Xshadow 0 def /w 0 def
|
|
3305 /YBox 0 def /width 0 def
|
|
3306 /YY 0 def /xi 0 def
|
|
3307 /Yshadow 0 def /xo 0 def
|
|
3308 /arrow 0 def /xp 0 def
|
|
3309 /bg false def /xt 0 def
|
|
3310 /bgcolor 0 def /xw 0 def
|
|
3311 /bordercolor 0 def /xx 0 def
|
|
3312 /borderwidth 0 def /yi 0 def
|
|
3313 /dd 0 def /yo 0 def
|
|
3314 /entry 0 def /yp 0 def
|
|
3315 /foreground 0 def /yt 0 def
|
|
3316 /yy 0 def
|
|
3317
|
|
3318
|
|
3319 % ISOLatin1Encoding stolen from ps_init.ps in GhostScript 2.6.1.4:
|
|
3320 /ISOLatin1Encoding where
|
|
3321 {pop}
|
|
3322 {% -- The ISO Latin-1 encoding vector isn't known, so define it.
|
|
3323 % -- The first half is the same as the standard encoding,
|
|
3324 % -- except for minus instead of hyphen at code 055.
|
|
3325 /ISOLatin1Encoding
|
|
3326 StandardEncoding 0 45 getinterval aload pop
|
|
3327 /minus
|
|
3328 StandardEncoding 46 82 getinterval aload pop
|
|
3329 %*** NOTE: the following are missing in the Adobe documentation,
|
|
3330 %*** but appear in the displayed table:
|
|
3331 %*** macron at 0225, dieresis at 0230, cedilla at 0233, space at 0240.
|
|
3332 % 0200 (128)
|
|
3333 /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
|
|
3334 /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
|
|
3335 /dotlessi /grave /acute /circumflex /tilde /macron /breve /dotaccent
|
|
3336 /dieresis /.notdef /ring /cedilla /.notdef /hungarumlaut /ogonek /caron
|
|
3337 % 0240 (160)
|
|
3338 /space /exclamdown /cent /sterling
|
|
3339 /currency /yen /brokenbar /section
|
|
3340 /dieresis /copyright /ordfeminine /guillemotleft
|
|
3341 /logicalnot /hyphen /registered /macron
|
|
3342 /degree /plusminus /twosuperior /threesuperior
|
|
3343 /acute /mu /paragraph /periodcentered
|
|
3344 /cedilla /onesuperior /ordmasculine /guillemotright
|
|
3345 /onequarter /onehalf /threequarters /questiondown
|
|
3346 % 0300 (192)
|
|
3347 /Agrave /Aacute /Acircumflex /Atilde
|
|
3348 /Adieresis /Aring /AE /Ccedilla
|
|
3349 /Egrave /Eacute /Ecircumflex /Edieresis
|
|
3350 /Igrave /Iacute /Icircumflex /Idieresis
|
|
3351 /Eth /Ntilde /Ograve /Oacute
|
|
3352 /Ocircumflex /Otilde /Odieresis /multiply
|
|
3353 /Oslash /Ugrave /Uacute /Ucircumflex
|
|
3354 /Udieresis /Yacute /Thorn /germandbls
|
|
3355 % 0340 (224)
|
|
3356 /agrave /aacute /acircumflex /atilde
|
|
3357 /adieresis /aring /ae /ccedilla
|
|
3358 /egrave /eacute /ecircumflex /edieresis
|
|
3359 /igrave /iacute /icircumflex /idieresis
|
|
3360 /eth /ntilde /ograve /oacute
|
|
3361 /ocircumflex /otilde /odieresis /divide
|
|
3362 /oslash /ugrave /uacute /ucircumflex
|
|
3363 /udieresis /yacute /thorn /ydieresis
|
|
3364 256 packedarray def
|
|
3365 }ifelse
|
|
3366
|
|
3367 /reencodeFontISO %def
|
|
3368 {dup
|
|
3369 length 12 add dict % Make a new font (a new dict the same size
|
|
3370 % as the old one) with room for our new symbols.
|
|
3371
|
|
3372 begin % Make the new font the current dictionary.
|
|
3373 {1 index /FID ne
|
|
3374 {def}{pop pop}ifelse
|
|
3375 }forall % Copy each of the symbols from the old dictionary
|
|
3376 % to the new one except for the font ID.
|
|
3377
|
|
3378 currentdict /FontType get 0 ne
|
|
3379 {/Encoding ISOLatin1Encoding def}if % Override the encoding with
|
|
3380 % the ISOLatin1 encoding.
|
|
3381
|
|
3382 % Use the font's bounding box to determine the ascent, descent,
|
|
3383 % and overall height; don't forget that these values have to be
|
|
3384 % transformed using the font's matrix.
|
|
3385
|
|
3386 % ^ (x2 y2)
|
|
3387 % | |
|
|
3388 % | v
|
|
3389 % | +----+ - -
|
|
3390 % | | | ^
|
|
3391 % | | | | Ascent (usually > 0)
|
|
3392 % | | | |
|
|
3393 % (0 0) -> +--+----+-------->
|
|
3394 % | | |
|
|
3395 % | | v Descent (usually < 0)
|
|
3396 % (x1 y1) --> +----+ - -
|
|
3397
|
|
3398 currentdict /FontType get 0 ne
|
|
3399 {/FontBBox load aload pop % -- x1 y1 x2 y2
|
|
3400 FontMatrix transform /Ascent exch def pop
|
|
3401 FontMatrix transform /Descent exch def pop}
|
|
3402 {/PrimaryFont FDepVector 0 get def
|
|
3403 PrimaryFont /FontBBox get aload pop
|
|
3404 PrimaryFont /FontMatrix get transform /Ascent exch def pop
|
|
3405 PrimaryFont /FontMatrix get transform /Descent exch def pop
|
|
3406 }ifelse
|
|
3407
|
|
3408 /FontHeight Ascent Descent sub def % use `sub' because descent < 0
|
|
3409
|
|
3410 % Define these in case they're not in the FontInfo
|
|
3411 % (also, here they're easier to get to).
|
|
3412 /UnderlinePosition Descent 0.70 mul def
|
|
3413 /OverlinePosition Descent UnderlinePosition sub Ascent add def
|
|
3414 /StrikeoutPosition Ascent 0.30 mul def
|
|
3415 /LineThickness FontHeight 0.05 mul def
|
|
3416 /Xshadow FontHeight 0.08 mul def
|
|
3417 /Yshadow FontHeight -0.09 mul def
|
|
3418 /SpaceBackground Descent neg UnderlinePosition add def
|
|
3419 /XBox Descent neg def
|
|
3420 /YBox LineThickness 0.7 mul def
|
|
3421
|
|
3422 currentdict % Leave the new font on the stack
|
|
3423 end % Stop using the font as the current dictionary
|
|
3424 definefont % Put the font into the font dictionary
|
|
3425 pop % Discard the returned font
|
|
3426 }bind def
|
|
3427
|
|
3428 % Font definition
|
|
3429 /DefFont{findfont exch scalefont reencodeFontISO}def
|
|
3430
|
|
3431 % Font selection
|
|
3432 /F
|
|
3433 {findfont
|
|
3434 dup /Ascent get /Ascent exch def
|
|
3435 dup /Descent get /Descent exch def
|
|
3436 dup /FontHeight get /FontHeight exch def
|
|
3437 dup /UnderlinePosition get /UnderlinePosition exch def
|
|
3438 dup /OverlinePosition get /OverlinePosition exch def
|
|
3439 dup /StrikeoutPosition get /StrikeoutPosition exch def
|
|
3440 dup /LineThickness get /LineThickness exch def
|
|
3441 dup /Xshadow get /Xshadow exch def
|
|
3442 dup /Yshadow get /Yshadow exch def
|
|
3443 dup /SpaceBackground get /SpaceBackground exch def
|
|
3444 dup /XBox get /XBox exch def
|
|
3445 dup /YBox get /YBox exch def
|
|
3446 setfont
|
|
3447 }def
|
|
3448
|
|
3449 /BG
|
|
3450 {dup /bg exch def
|
|
3451 {mark 4 1 roll ]}
|
|
3452 {[ 1.0 1.0 1.0 ]}
|
|
3453 ifelse
|
|
3454 /bgcolor exch def
|
|
3455 }def
|
|
3456
|
|
3457 % stack: --
|
|
3458 /FillBgColor{bgcolor aload pop setrgbcolor fill}bind def
|
|
3459
|
|
3460 % stack: fill-or-not lower-x lower-y upper-x upper-y |- --
|
|
3461 /doRect
|
|
3462 {/rYY exch def
|
|
3463 /rXX exch def
|
|
3464 /ryy exch def
|
|
3465 /rxx exch def
|
|
3466 gsave
|
|
3467 newpath
|
|
3468 rXX rYY moveto
|
|
3469 rxx rYY lineto
|
|
3470 rxx ryy lineto
|
|
3471 rXX ryy lineto
|
|
3472 closepath
|
|
3473 % top of stack: fill-or-not
|
|
3474 {FillBgColor}
|
|
3475 {LineThickness setlinewidth stroke}
|
|
3476 ifelse
|
|
3477 grestore
|
|
3478 }bind def
|
|
3479
|
|
3480 % stack: string fill-or-not |- --
|
|
3481 /doOutline
|
|
3482 {/-fillp- exch def
|
|
3483 /-ox- currentpoint /-oy- exch def def
|
|
3484 gsave
|
|
3485 LineThickness setlinewidth
|
|
3486 {st 0 3 -1 roll put
|
|
3487 st dup true charpath
|
|
3488 -fillp- {gsave FillBgColor grestore}if
|
|
3489 stroke stringwidth
|
|
3490 -oy- add /-oy- exch def
|
|
3491 -ox- add /-ox- exch def
|
|
3492 -ox- -oy- moveto
|
|
3493 }forall
|
|
3494 grestore
|
|
3495 -ox- -oy- moveto
|
|
3496 }bind def
|
|
3497
|
|
3498 % stack: fill-or-not delta |- --
|
|
3499 /doBox
|
|
3500 {/dd exch def
|
|
3501 xx XBox sub dd sub yy YBox sub dd sub
|
|
3502 XX XBox add dd add YY YBox add dd add
|
|
3503 doRect
|
|
3504 }bind def
|
|
3505
|
|
3506 % stack: string |- --
|
|
3507 /doShadow
|
|
3508 {gsave
|
|
3509 Xshadow Yshadow rmoveto
|
|
3510 false doOutline
|
|
3511 grestore
|
|
3512 }bind def
|
|
3513
|
|
3514 % stack: position |- --
|
|
3515 /Hline
|
|
3516 {currentpoint exch pop add dup
|
|
3517 gsave
|
|
3518 newpath
|
|
3519 xx exch moveto
|
|
3520 XX exch lineto
|
|
3521 closepath
|
|
3522 LineThickness setlinewidth stroke
|
|
3523 grestore
|
|
3524 }bind def
|
|
3525
|
|
3526 % stack: string |- --
|
|
3527 % effect: 1 - underline 2 - strikeout 4 - overline
|
|
3528 % 8 - shadow 16 - box 32 - outline
|
|
3529 /S
|
|
3530 {/xx currentpoint dup Descent add /yy exch def
|
|
3531 Ascent add /YY exch def def
|
|
3532 dup stringwidth pop xx add /XX exch def
|
|
3533 Effect 8 and 0 ne
|
|
3534 {/yy yy Yshadow add def
|
|
3535 /XX XX Xshadow add def
|
|
3536 }if
|
|
3537 bg
|
|
3538 {true
|
|
3539 Effect 16 and 0 ne
|
|
3540 {SpaceBackground doBox}
|
|
3541 {xx yy XX YY doRect}
|
|
3542 ifelse
|
|
3543 }if % background
|
|
3544 Effect 16 and 0 ne{false 0 doBox}if % box
|
|
3545 Effect 8 and 0 ne{dup doShadow}if % shadow
|
|
3546 Effect 32 and 0 ne
|
|
3547 {true doOutline} % outline
|
|
3548 {show} % normal text
|
|
3549 ifelse
|
|
3550 Effect 1 and 0 ne{UnderlinePosition Hline}if % underline
|
|
3551 Effect 2 and 0 ne{StrikeoutPosition Hline}if % strikeout
|
|
3552 Effect 4 and 0 ne{OverlinePosition Hline}if % overline
|
|
3553 }bind def
|
|
3554
|
|
3555 "
|
|
3556 "EBNF EPS prologue")
|
|
3557
|
|
3558
|
|
3559 (defconst ebnf-eps-begin
|
|
3560 "
|
|
3561 end
|
|
3562
|
|
3563 % x y #ebnf2ps#begin
|
|
3564 /#ebnf2ps#begin
|
|
3565 {#ebnf2ps#dict begin /#ebnf2ps#save save def
|
|
3566 moveto false BG 0.0 0.0 0.0 setrgbcolor}def
|
|
3567
|
|
3568 /#ebnf2ps#end{showpage #ebnf2ps#save restore end}def
|
|
3569
|
|
3570 %%EndPrologue
|
|
3571 "
|
|
3572 "EBNF EPS begin")
|
|
3573
|
|
3574
|
|
3575 (defconst ebnf-eps-end
|
|
3576 "#ebnf2ps#end
|
|
3577 %%EOF
|
|
3578 "
|
|
3579 "EBNF EPS end")
|
|
3580
|
|
3581
|
|
3582 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
3583 ;; Formatting
|
|
3584
|
|
3585
|
|
3586 (defvar ebnf-format-float "%1.3f")
|
|
3587
|
|
3588
|
|
3589 (defun ebnf-format-float (&rest floats)
|
|
3590 (mapconcat
|
|
3591 #'(lambda (float)
|
|
3592 (format ebnf-format-float float))
|
|
3593 floats
|
|
3594 " "))
|
|
3595
|
|
3596
|
|
3597 (defun ebnf-format-color (format-str color default)
|
|
3598 (let* ((the-color (or color default))
|
|
3599 (rgb (mapcar 'ps-color-value (ps-color-values the-color))))
|
|
3600 (format format-str
|
|
3601 (concat "["
|
|
3602 (ebnf-format-float (nth 0 rgb) (nth 1 rgb) (nth 2 rgb))
|
|
3603 "]")
|
|
3604 the-color)))
|
|
3605
|
|
3606
|
|
3607 (defvar ebnf-message-float "%3.2f")
|
|
3608
|
|
3609
|
|
3610 (defsubst ebnf-message-float (format-str value)
|
|
3611 (message format-str
|
|
3612 (format ebnf-message-float value)))
|
|
3613
|
|
3614
|
|
3615 (defsubst ebnf-message-info (messag)
|
|
3616 (message "%s...%3d%%"
|
|
3617 messag
|
|
3618 (round (/ (* (setq ebnf-nprod (1+ ebnf-nprod)) 100.0) ebnf-total))))
|
|
3619
|
|
3620
|
|
3621 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
3622 ;; Macros
|
|
3623
|
|
3624
|
|
3625 (defmacro ebnf-node-kind (vec &optional value)
|
|
3626 (if value
|
|
3627 `(aset ,vec 0 ,value)
|
|
3628 `(aref ,vec 0)))
|
|
3629
|
|
3630
|
|
3631 (defmacro ebnf-node-width-func (node width)
|
|
3632 `(funcall (aref ,node 1) ,node ,width))
|
|
3633
|
|
3634
|
|
3635 (defmacro ebnf-node-dimension-func (node &optional value)
|
|
3636 (if value
|
|
3637 `(aset ,node 2 ,value)
|
|
3638 `(funcall (aref ,node 2) ,node)))
|
|
3639
|
|
3640
|
|
3641 (defmacro ebnf-node-entry (vec &optional value)
|
|
3642 (if value
|
|
3643 `(aset ,vec 3 ,value)
|
|
3644 `(aref ,vec 3)))
|
|
3645
|
|
3646
|
|
3647 (defmacro ebnf-node-height (vec &optional value)
|
|
3648 (if value
|
|
3649 `(aset ,vec 4 ,value)
|
|
3650 `(aref ,vec 4)))
|
|
3651
|
|
3652
|
|
3653 (defmacro ebnf-node-width (vec &optional value)
|
|
3654 (if value
|
|
3655 `(aset ,vec 5 ,value)
|
|
3656 `(aref ,vec 5)))
|
|
3657
|
|
3658
|
|
3659 (defmacro ebnf-node-name (vec)
|
|
3660 `(aref ,vec 6))
|
|
3661
|
|
3662
|
|
3663 (defmacro ebnf-node-list (vec &optional value)
|
|
3664 (if value
|
|
3665 `(aset ,vec 6 ,value)
|
|
3666 `(aref ,vec 6)))
|
|
3667
|
|
3668
|
|
3669 (defmacro ebnf-node-default (vec)
|
|
3670 `(aref ,vec 7))
|
|
3671
|
|
3672
|
|
3673 (defmacro ebnf-node-production (vec &optional value)
|
|
3674 (if value
|
|
3675 `(aset ,vec 7 ,value)
|
|
3676 `(aref ,vec 7)))
|
|
3677
|
|
3678
|
|
3679 (defmacro ebnf-node-separator (vec &optional value)
|
|
3680 (if value
|
|
3681 `(aset ,vec 7 ,value)
|
|
3682 `(aref ,vec 7)))
|
|
3683
|
|
3684
|
|
3685 (defmacro ebnf-node-action (vec &optional value)
|
|
3686 (if value
|
|
3687 `(aset ,vec 8 ,value)
|
|
3688 `(aref ,vec 8)))
|
|
3689
|
|
3690
|
|
3691 (defmacro ebnf-node-generation (node)
|
|
3692 `(funcall (ebnf-node-kind ,node) ,node))
|
|
3693
|
|
3694
|
|
3695 (defmacro ebnf-max-width (prod)
|
|
3696 `(max (ebnf-node-width ,prod)
|
|
3697 (+ (* (length (ebnf-node-name ,prod))
|
|
3698 ebnf-font-width-P)
|
|
3699 ebnf-production-horizontal-space)))
|
|
3700
|
|
3701
|
|
3702 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
3703 ;; PostScript generation
|
|
3704
|
|
3705
|
|
3706 (defun ebnf-generate-eps (ebnf-tree)
|
|
3707 (let* ((ps-color-p (and ebnf-color-p (ps-color-device)))
|
|
3708 (ps-print-color-scale (if ps-color-p
|
|
3709 (float (car (ps-color-values "white")))
|
|
3710 1.0))
|
|
3711 (ebnf-total (length ebnf-tree))
|
|
3712 (ebnf-nprod 0)
|
|
3713 (old-ps-output (symbol-function 'ps-output))
|
|
3714 (old-ps-output-string (symbol-function 'ps-output-string))
|
|
3715 (eps-buffer (get-buffer-create ebnf-eps-buffer-name))
|
|
3716 ebnf-debug-ps error-msg horizontal
|
|
3717 prod prod-name prod-width prod-height prod-list file-list)
|
|
3718 ;; redefines `ps-output' and `ps-output-string'
|
|
3719 (defalias 'ps-output 'ebnf-eps-output)
|
|
3720 (defalias 'ps-output-string 'ps-output-string-prim)
|
|
3721 ;; generate EPS file
|
|
3722 (save-excursion
|
|
3723 (condition-case data
|
|
3724 (progn
|
|
3725 (while ebnf-tree
|
|
3726 (setq prod (car ebnf-tree)
|
|
3727 prod-name (ebnf-node-name prod)
|
|
3728 prod-width (ebnf-max-width prod)
|
|
3729 prod-height (ebnf-node-height prod)
|
|
3730 horizontal (memq (ebnf-node-action prod) ebnf-action-list))
|
|
3731 ;; generate production in EPS buffer
|
|
3732 (save-excursion
|
|
3733 (set-buffer eps-buffer)
|
|
3734 (setq ebnf-eps-upper-x 0.0
|
|
3735 ebnf-eps-upper-y 0.0
|
|
3736 ebnf-eps-max-width prod-width
|
|
3737 ebnf-eps-max-height prod-height)
|
|
3738 (ebnf-generate-production prod))
|
|
3739 (if (setq prod-list (cdr (assoc prod-name
|
|
3740 ebnf-eps-production-list)))
|
|
3741 ;; insert EPS buffer in all buffer associated with production
|
|
3742 (ebnf-eps-production-list prod-list 'file-list horizontal
|
|
3743 prod-width prod-height eps-buffer)
|
|
3744 ;; write EPS file for production
|
|
3745 (ebnf-eps-finish-and-write eps-buffer
|
|
3746 (ebnf-eps-filename prod-name)))
|
|
3747 ;; prepare for next loop
|
|
3748 (save-excursion
|
|
3749 (set-buffer eps-buffer)
|
|
3750 (erase-buffer))
|
|
3751 (setq ebnf-tree (cdr ebnf-tree)))
|
|
3752 ;; write and kill temporary buffers
|
|
3753 (ebnf-eps-write-kill-temp file-list t)
|
|
3754 (setq file-list nil))
|
|
3755 ;; handler
|
|
3756 ((quit error)
|
|
3757 (setq error-msg (error-message-string data)))))
|
|
3758 ;; restore `ps-output' and `ps-output-string'
|
|
3759 (defalias 'ps-output old-ps-output)
|
|
3760 (defalias 'ps-output-string old-ps-output-string)
|
|
3761 ;; kill temporary buffers
|
|
3762 (kill-buffer eps-buffer)
|
|
3763 (ebnf-eps-write-kill-temp file-list nil)
|
|
3764 (and error-msg (error error-msg))
|
|
3765 (message " ")))
|
|
3766
|
|
3767
|
|
3768 ;; write and kill temporary buffers
|
|
3769 (defun ebnf-eps-write-kill-temp (file-list write-p)
|
|
3770 (while file-list
|
|
3771 (let ((buffer (get-buffer (concat " *" (car file-list) "*"))))
|
|
3772 (when buffer
|
|
3773 (and write-p
|
|
3774 (ebnf-eps-finish-and-write buffer (car file-list)))
|
|
3775 (kill-buffer buffer)))
|
|
3776 (setq file-list (cdr file-list))))
|
|
3777
|
|
3778
|
|
3779 ;; insert EPS buffer in all buffer associated with production
|
|
3780 (defun ebnf-eps-production-list (prod-list file-list-sym horizontal
|
|
3781 prod-width prod-height eps-buffer)
|
|
3782 (while prod-list
|
|
3783 (add-to-list file-list-sym (car prod-list))
|
|
3784 (save-excursion
|
|
3785 (set-buffer (get-buffer-create (concat " *" (car prod-list) "*")))
|
|
3786 (goto-char (point-max))
|
|
3787 (cond
|
|
3788 ;; first production
|
|
3789 ((zerop (buffer-size))
|
|
3790 (setq ebnf-eps-upper-x 0.0
|
|
3791 ebnf-eps-upper-y 0.0
|
|
3792 ebnf-eps-max-width prod-width
|
|
3793 ebnf-eps-max-height prod-height))
|
|
3794 ;; horizontal
|
|
3795 (horizontal
|
|
3796 (ebnf-eop-horizontal ebnf-eps-prod-width)
|
|
3797 (setq ebnf-eps-max-width (+ ebnf-eps-max-width
|
|
3798 ebnf-production-horizontal-space
|
|
3799 prod-width)
|
|
3800 ebnf-eps-max-height (max ebnf-eps-max-height prod-height)))
|
|
3801 ;; vertical
|
|
3802 (t
|
|
3803 (ebnf-eop-vertical ebnf-eps-max-height)
|
|
3804 (setq ebnf-eps-upper-x (max ebnf-eps-upper-x ebnf-eps-max-width)
|
|
3805 ebnf-eps-upper-y (if (zerop ebnf-eps-upper-y)
|
|
3806 ebnf-eps-max-height
|
|
3807 (+ ebnf-eps-upper-y
|
|
3808 ebnf-production-vertical-space
|
|
3809 ebnf-eps-max-height))
|
|
3810 ebnf-eps-max-width prod-width
|
|
3811 ebnf-eps-max-height prod-height))
|
|
3812 )
|
|
3813 (setq ebnf-eps-prod-width prod-width)
|
|
3814 (insert-buffer eps-buffer))
|
|
3815 (setq prod-list (cdr prod-list))))
|
|
3816
|
|
3817
|
|
3818 (defun ebnf-generate (ebnf-tree)
|
|
3819 (let* ((ps-color-p (and ebnf-color-p (ps-color-device)))
|
|
3820 (ps-print-color-scale (if ps-color-p
|
|
3821 (float (car (ps-color-values "white")))
|
|
3822 1.0))
|
|
3823 ps-zebra-stripes ps-line-number ps-razzle-dazzle
|
|
3824 ps-print-hook
|
|
3825 ps-print-begin-sheet-hook
|
|
3826 ps-print-begin-page-hook
|
|
3827 ps-print-begin-column-hook)
|
|
3828 (ps-generate (current-buffer) (point-min) (point-max)
|
|
3829 'ebnf-generate-postscript)))
|
|
3830
|
|
3831
|
|
3832 (defvar ebnf-tree nil)
|
|
3833 (defvar ebnf-direction "R")
|
|
3834 (defvar ebnf-total 0)
|
|
3835 (defvar ebnf-nprod 0)
|
|
3836
|
|
3837
|
|
3838 (defun ebnf-generate-postscript (from to)
|
|
3839 (ebnf-begin-file)
|
|
3840 (if ebnf-horizontal-max-height
|
|
3841 (ebnf-generate-with-max-height)
|
|
3842 (ebnf-generate-without-max-height))
|
|
3843 (message " "))
|
|
3844
|
|
3845
|
|
3846 (defun ebnf-generate-with-max-height ()
|
|
3847 (let ((ebnf-total (length ebnf-tree))
|
|
3848 (ebnf-nprod 0)
|
|
3849 next-line max-height prod the-width)
|
|
3850 (while ebnf-tree
|
|
3851 ;; find next line point
|
|
3852 (setq next-line ebnf-tree
|
|
3853 prod (car ebnf-tree)
|
|
3854 max-height (ebnf-node-height prod))
|
|
3855 (ebnf-begin-line prod (ebnf-max-width prod))
|
|
3856 (while (and (setq next-line (cdr next-line))
|
|
3857 (setq prod (car next-line))
|
|
3858 (memq (ebnf-node-action prod) ebnf-action-list)
|
|
3859 (setq the-width (ebnf-max-width prod))
|
|
3860 (<= the-width ps-width-remaining))
|
|
3861 (setq max-height (max max-height (ebnf-node-height prod))
|
|
3862 ps-width-remaining (- ps-width-remaining
|
|
3863 (+ the-width
|
|
3864 ebnf-production-horizontal-space))))
|
|
3865 ;; generate current line
|
|
3866 (ebnf-newline max-height)
|
|
3867 (setq prod (car ebnf-tree))
|
|
3868 (ebnf-generate-production prod)
|
|
3869 (while (not (eq (setq ebnf-tree (cdr ebnf-tree)) next-line))
|
|
3870 (ebnf-eop-horizontal (ebnf-max-width prod))
|
|
3871 (setq prod (car ebnf-tree))
|
|
3872 (ebnf-generate-production prod))
|
|
3873 (ebnf-eop-vertical max-height))))
|
|
3874
|
|
3875
|
|
3876 (defun ebnf-generate-without-max-height ()
|
|
3877 (let ((ebnf-total (length ebnf-tree))
|
|
3878 (ebnf-nprod 0)
|
|
3879 max-height prod bef-width cur-width)
|
|
3880 (while ebnf-tree
|
|
3881 ;; generate current line
|
|
3882 (setq prod (car ebnf-tree)
|
|
3883 max-height (ebnf-node-height prod)
|
|
3884 bef-width (ebnf-max-width prod))
|
|
3885 (ebnf-begin-line prod bef-width)
|
|
3886 (ebnf-generate-production prod)
|
|
3887 (while (and (setq ebnf-tree (cdr ebnf-tree))
|
|
3888 (setq prod (car ebnf-tree))
|
|
3889 (memq (ebnf-node-action prod) ebnf-action-list)
|
|
3890 (setq cur-width (ebnf-max-width prod))
|
|
3891 (<= cur-width ps-width-remaining)
|
|
3892 (<= (ebnf-node-height prod) ps-height-remaining))
|
|
3893 (ebnf-eop-horizontal bef-width)
|
|
3894 (ebnf-generate-production prod)
|
|
3895 (setq bef-width cur-width
|
|
3896 max-height (max max-height (ebnf-node-height prod))
|
|
3897 ps-width-remaining (- ps-width-remaining
|
|
3898 (+ cur-width
|
|
3899 ebnf-production-horizontal-space))))
|
|
3900 (ebnf-eop-vertical max-height)
|
|
3901 ;; prepare next line
|
|
3902 (ebnf-newline max-height))))
|
|
3903
|
|
3904
|
|
3905 (defun ebnf-begin-line (prod width)
|
|
3906 (and (or (eq (ebnf-node-action prod) 'form-feed)
|
|
3907 (> (ebnf-node-height prod) ps-height-remaining))
|
|
3908 (ebnf-new-page))
|
|
3909 (setq ps-width-remaining (- ps-width-remaining
|
|
3910 (+ width
|
|
3911 ebnf-production-horizontal-space))))
|
|
3912
|
|
3913
|
|
3914 (defun ebnf-newline (height)
|
|
3915 (and (> height ps-height-remaining)
|
|
3916 (ebnf-new-page))
|
|
3917 (setq ps-width-remaining ps-print-width
|
|
3918 ps-height-remaining (- ps-height-remaining
|
|
3919 (+ height
|
|
3920 ebnf-production-vertical-space))))
|
|
3921
|
|
3922
|
|
3923 ;; [production width-fun dim-fun entry height width name production action]
|
|
3924 (defun ebnf-generate-production (production)
|
|
3925 (ebnf-message-info "Generating")
|
|
3926 (run-hooks 'ebnf-production-hook)
|
|
3927 (ps-output-string (ebnf-node-name production))
|
|
3928 (ps-output " "
|
|
3929 (ebnf-format-float
|
|
3930 (ebnf-node-width production)
|
|
3931 (+ ebnf-basic-height
|
|
3932 (ebnf-node-entry (ebnf-node-production production))))
|
|
3933 " BOP\n")
|
|
3934 (ebnf-node-generation (ebnf-node-production production))
|
|
3935 (ps-output "EOS\n"))
|
|
3936
|
|
3937
|
|
3938 ;; [alternative width-fun dim-fun entry height width list]
|
|
3939 (defun ebnf-generate-alternative (alternative)
|
|
3940 (let ((alt (ebnf-node-list alternative))
|
|
3941 (entry (ebnf-node-entry alternative))
|
|
3942 (nlist 0)
|
|
3943 alt-height alt-entry)
|
|
3944 (while alt
|
|
3945 (ps-output (ebnf-format-float (- entry (ebnf-node-entry (car alt))))
|
|
3946 " ")
|
|
3947 (setq entry (- entry (ebnf-node-height (car alt)) ebnf-vertical-space)
|
|
3948 nlist (1+ nlist)
|
|
3949 alt (cdr alt)))
|
|
3950 (ps-output (format "%d " nlist)
|
|
3951 (ebnf-format-float (ebnf-node-width alternative))
|
|
3952 " AT\n")
|
|
3953 (setq alt (ebnf-node-list alternative))
|
|
3954 (when alt
|
|
3955 (ebnf-node-generation (car alt))
|
|
3956 (setq alt-height (- (ebnf-node-height (car alt))
|
|
3957 (ebnf-node-entry (car alt)))))
|
|
3958 (while (setq alt (cdr alt))
|
|
3959 (setq alt-entry (ebnf-node-entry (car alt)))
|
|
3960 (ebnf-vertical-movement
|
|
3961 (- (+ alt-height ebnf-vertical-space alt-entry)))
|
|
3962 (ebnf-node-generation (car alt))
|
|
3963 (setq alt-height (- (ebnf-node-height (car alt)) alt-entry))))
|
|
3964 (ps-output "EOS\n"))
|
|
3965
|
|
3966
|
|
3967 ;; [sequence width-fun dim-fun entry height width list]
|
|
3968 (defun ebnf-generate-sequence (sequence)
|
|
3969 (ps-output "BOS\n")
|
|
3970 (let ((seq (ebnf-node-list sequence))
|
|
3971 seq-width)
|
|
3972 (when seq
|
|
3973 (ebnf-node-generation (car seq))
|
|
3974 (setq seq-width (ebnf-node-width (car seq))))
|
|
3975 (while (setq seq (cdr seq))
|
|
3976 (ebnf-horizontal-movement seq-width)
|
|
3977 (ebnf-node-generation (car seq))
|
|
3978 (setq seq-width (ebnf-node-width (car seq)))))
|
|
3979 (ps-output "EOS\n"))
|
|
3980
|
|
3981
|
|
3982 ;; [terminal width-fun dim-fun entry height width name]
|
|
3983 (defun ebnf-generate-terminal (terminal)
|
|
3984 (ebnf-gen-terminal terminal "T"))
|
|
3985
|
|
3986
|
|
3987 ;; [non-terminal width-fun dim-fun entry height width name]
|
|
3988 (defun ebnf-generate-non-terminal (non-terminal)
|
|
3989 (ebnf-gen-terminal non-terminal "NT"))
|
|
3990
|
|
3991
|
|
3992 ;; [empty width-fun dim-fun entry height width]
|
|
3993 (defun ebnf-generate-empty (empty)
|
|
3994 (ebnf-empty-alternative (ebnf-node-width empty)))
|
|
3995
|
|
3996
|
|
3997 ;; [optional width-fun dim-fun entry height width element]
|
|
3998 (defun ebnf-generate-optional (optional)
|
|
3999 (let ((the-optional (ebnf-node-list optional)))
|
|
4000 (ps-output (ebnf-format-float
|
|
4001 (+ (- (ebnf-node-height the-optional)
|
|
4002 (ebnf-node-entry optional))
|
|
4003 ebnf-vertical-space)
|
|
4004 (ebnf-node-width optional))
|
|
4005 " OP\n")
|
|
4006 (ebnf-node-generation the-optional)
|
|
4007 (ps-output "EOS\n")))
|
|
4008
|
|
4009
|
|
4010 ;; [one-or-more width-fun dim-fun entry height width element separator]
|
|
4011 (defun ebnf-generate-one-or-more (one-or-more)
|
|
4012 (let* ((width (ebnf-node-width one-or-more))
|
|
4013 (sep (ebnf-node-separator one-or-more))
|
|
4014 (entry (- (ebnf-node-entry one-or-more)
|
|
4015 (if sep
|
|
4016 (ebnf-node-entry sep)
|
|
4017 0))))
|
|
4018 (ps-output (ebnf-format-float entry width)
|
|
4019 " OM\n")
|
|
4020 (ebnf-node-generation (ebnf-node-list one-or-more))
|
|
4021 (ebnf-vertical-movement entry)
|
|
4022 (if sep
|
|
4023 (let ((ebnf-direction "L"))
|
|
4024 (ebnf-node-generation sep))
|
|
4025 (ebnf-empty-alternative (- width ebnf-horizontal-space))))
|
|
4026 (ps-output "EOS\n"))
|
|
4027
|
|
4028
|
|
4029 ;; [zero-or-more width-fun dim-fun entry height width element separator]
|
|
4030 (defun ebnf-generate-zero-or-more (zero-or-more)
|
|
4031 (let* ((width (ebnf-node-width zero-or-more))
|
|
4032 (node-list (ebnf-node-list zero-or-more))
|
|
4033 (list-entry (ebnf-node-entry node-list))
|
|
4034 (node-sep (ebnf-node-separator zero-or-more))
|
|
4035 (entry (+ list-entry
|
|
4036 ebnf-vertical-space
|
|
4037 (if node-sep
|
|
4038 (- (ebnf-node-height node-sep)
|
|
4039 (ebnf-node-entry node-sep))
|
|
4040 0))))
|
|
4041 (ps-output (ebnf-format-float entry
|
|
4042 (+ (- (ebnf-node-height node-list)
|
|
4043 list-entry)
|
|
4044 ebnf-vertical-space)
|
|
4045 width)
|
|
4046 " ZM\n")
|
|
4047 (ebnf-node-generation (ebnf-node-list zero-or-more))
|
|
4048 (ebnf-vertical-movement entry)
|
|
4049 (if (ebnf-node-separator zero-or-more)
|
|
4050 (let ((ebnf-direction "L"))
|
|
4051 (ebnf-node-generation (ebnf-node-separator zero-or-more)))
|
|
4052 (ebnf-empty-alternative (- width ebnf-horizontal-space))))
|
|
4053 (ps-output "EOS\n"))
|
|
4054
|
|
4055
|
|
4056 ;; [special width-fun dim-fun entry height width name]
|
|
4057 (defun ebnf-generate-special (special)
|
|
4058 (ebnf-gen-terminal special "SP"))
|
|
4059
|
|
4060
|
|
4061 ;; [repeat width-fun dim-fun entry height width times element]
|
|
4062 (defun ebnf-generate-repeat (repeat)
|
|
4063 (let ((times (ebnf-node-name repeat))
|
|
4064 (element (ebnf-node-separator repeat)))
|
|
4065 (ps-output-string times)
|
|
4066 (ps-output " "
|
|
4067 (ebnf-format-float
|
|
4068 (ebnf-node-entry repeat)
|
|
4069 (ebnf-node-height repeat)
|
|
4070 (ebnf-node-width repeat)
|
|
4071 (if element
|
|
4072 (+ (ebnf-node-width element)
|
|
4073 ebnf-space-R ebnf-space-R ebnf-space-R
|
|
4074 (* (length times) ebnf-font-width-R))
|
|
4075 0.0))
|
|
4076 " " ebnf-direction "RP\n")
|
|
4077 (and element
|
|
4078 (ebnf-node-generation element)))
|
|
4079 (ps-output "EOS\n"))
|
|
4080
|
|
4081
|
|
4082 ;; [except width-fun dim-fun entry height width element element]
|
|
4083 (defun ebnf-generate-except (except)
|
|
4084 (let* ((element (ebnf-node-list except))
|
|
4085 (exception (ebnf-node-separator except))
|
|
4086 (width (ebnf-node-width element)))
|
|
4087 (ps-output (ebnf-format-float
|
|
4088 width
|
|
4089 (ebnf-node-entry except)
|
|
4090 (ebnf-node-height except)
|
|
4091 (ebnf-node-width except)
|
|
4092 (+ width
|
|
4093 ebnf-space-E ebnf-space-E ebnf-space-E
|
|
4094 ebnf-font-width-E
|
|
4095 (if exception
|
|
4096 (+ (ebnf-node-width exception) ebnf-space-E)
|
|
4097 0.0)))
|
|
4098 " " ebnf-direction "EX\n")
|
|
4099 (ebnf-node-generation (ebnf-node-list except))
|
|
4100 (when exception
|
|
4101 (ebnf-horizontal-movement (+ width ebnf-space-E
|
|
4102 ebnf-font-width-E ebnf-space-E))
|
|
4103 (ebnf-node-generation exception)))
|
|
4104 (ps-output "EOS\n"))
|
|
4105
|
|
4106
|
|
4107 (defun ebnf-gen-terminal (node code)
|
|
4108 (ps-output-string (ebnf-node-name node))
|
|
4109 (ps-output " " (ebnf-format-float (ebnf-node-width node))
|
|
4110 " " ebnf-direction code
|
|
4111 (if (ebnf-node-default node)
|
|
4112 "D\n"
|
|
4113 "\n")))
|
|
4114
|
|
4115
|
|
4116 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
4117 ;; Internal functions
|
|
4118
|
|
4119
|
|
4120 (defvar ebnf-map-name
|
|
4121 (let ((map (make-vector 256 ?\_)))
|
|
4122 (mapcar #'(lambda (char)
|
|
4123 (aset map char char))
|
|
4124 (concat "#$%&+-.0123456789=?@~"
|
|
4125 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
|
|
4126 "abcdefghijklmnopqrstuvwxyz"))
|
|
4127 map))
|
|
4128
|
|
4129
|
|
4130 (defun ebnf-eps-filename (str)
|
|
4131 (let* ((len (length str))
|
|
4132 (stri 0)
|
|
4133 (new (make-string len ?\ )))
|
|
4134 (while (< stri len)
|
|
4135 (aset new stri (aref ebnf-map-name (aref str stri)))
|
|
4136 (setq stri (1+ stri)))
|
|
4137 (concat ebnf-eps-prefix new ".eps")))
|
|
4138
|
|
4139
|
|
4140 (defun ebnf-eps-output (&rest args)
|
|
4141 (while args
|
|
4142 (insert (car args))
|
|
4143 (setq args (cdr args))))
|
|
4144
|
|
4145
|
|
4146 (defun ebnf-generate-region (from to gen-func)
|
|
4147 (run-hooks 'ebnf-hook)
|
|
4148 (let ((ebnf-limit (max from to))
|
|
4149 the-point)
|
|
4150 (save-excursion
|
|
4151 (save-restriction
|
|
4152 (save-match-data
|
|
4153 (condition-case data
|
|
4154 (let ((tree (ebnf-parse-and-sort (min from to))))
|
|
4155 (when gen-func
|
|
4156 (funcall gen-func
|
|
4157 (ebnf-dimensions
|
|
4158 (ebnf-optimize
|
|
4159 (ebnf-eliminate-empty-rules tree))))))
|
|
4160 ;; handler
|
|
4161 ((quit error)
|
|
4162 (ding)
|
|
4163 (setq the-point (max (1- (point)) (point-min)))
|
|
4164 (message (error-message-string data)))))))
|
|
4165 (cond
|
|
4166 (the-point
|
|
4167 (goto-char the-point))
|
|
4168 (gen-func
|
|
4169 nil)
|
|
4170 (t
|
|
4171 (message "EBNF syntatic analysis: NO ERRORS.")))))
|
|
4172
|
|
4173
|
|
4174 (defun ebnf-parse-and-sort (start)
|
|
4175 (ebnf-begin-job)
|
|
4176 (let ((tree (funcall ebnf-parser-func start)))
|
|
4177 (if ebnf-sort-production
|
|
4178 (progn
|
|
4179 (message "Sorting...")
|
|
4180 (sort tree
|
|
4181 (if (eq ebnf-sort-production 'ascending)
|
|
4182 'ebnf-sorter-ascending
|
|
4183 'ebnf-sorter-descending)))
|
|
4184 (nreverse tree))))
|
|
4185
|
|
4186
|
|
4187 (defun ebnf-sorter-ascending (first second)
|
|
4188 (string< (ebnf-node-name first)
|
|
4189 (ebnf-node-name second)))
|
|
4190
|
|
4191
|
|
4192 (defun ebnf-sorter-descending (first second)
|
|
4193 (string< (ebnf-node-name second)
|
|
4194 (ebnf-node-name first)))
|
|
4195
|
|
4196
|
|
4197 (defun ebnf-empty-alternative (width)
|
|
4198 (ps-output (ebnf-format-float width) " EA\n"))
|
|
4199
|
|
4200
|
|
4201 (defun ebnf-vertical-movement (height)
|
|
4202 (ps-output (ebnf-format-float height) " vm\n"))
|
|
4203
|
|
4204
|
|
4205 (defun ebnf-horizontal-movement (width)
|
|
4206 (ps-output (ebnf-format-float width) " hm\n"))
|
|
4207
|
|
4208
|
|
4209 (defun ebnf-entry (height)
|
|
4210 (* height ebnf-entry-percentage))
|
|
4211
|
|
4212
|
|
4213 (defun ebnf-eop-vertical (height)
|
|
4214 (ps-output (ebnf-format-float (+ height ebnf-production-vertical-space))
|
|
4215 " EOPV\n\n"))
|
|
4216
|
|
4217
|
|
4218 (defun ebnf-eop-horizontal (width)
|
|
4219 (ps-output (ebnf-format-float (+ width ebnf-production-horizontal-space))
|
|
4220 " EOPH\n\n"))
|
|
4221
|
|
4222
|
|
4223 (defun ebnf-new-page ()
|
|
4224 (when (< ps-height-remaining ps-print-height)
|
|
4225 (run-hooks 'ebnf-page-hook)
|
|
4226 (ps-next-page)
|
|
4227 (ps-output "\n")))
|
|
4228
|
|
4229
|
|
4230 (defsubst ebnf-font-size (font) (nth 0 font))
|
|
4231 (defsubst ebnf-font-name (font) (nth 1 font))
|
|
4232 (defsubst ebnf-font-foreground (font) (nth 2 font))
|
|
4233 (defsubst ebnf-font-background (font) (nth 3 font))
|
|
4234 (defsubst ebnf-font-list (font) (nthcdr 4 font))
|
|
4235 (defsubst ebnf-font-attributes (font)
|
|
4236 (lsh (ps-extension-bit (cdr font)) -2))
|
|
4237
|
|
4238
|
|
4239 (defconst ebnf-font-name-select
|
|
4240 (vector 'normal 'bold 'italic 'bold-italic))
|
|
4241
|
|
4242
|
|
4243 (defun ebnf-font-name-select (font)
|
|
4244 (let* ((font-list (ebnf-font-list font))
|
|
4245 (font-index (+ (if (memq 'bold font-list) 1 0)
|
|
4246 (if (memq 'italic font-list) 2 0)))
|
|
4247 (name (ebnf-font-name font))
|
|
4248 (database (cdr (assoc name ps-font-info-database)))
|
|
4249 (info-list (or (cdr (assoc 'fonts database))
|
|
4250 (error "Invalid font: %s" name))))
|
|
4251 (or (cdr (assoc (aref ebnf-font-name-select font-index)
|
|
4252 info-list))
|
|
4253 (error "Invalid attributes for font %s" name))))
|
|
4254
|
|
4255
|
|
4256 (defun ebnf-font-select (font select)
|
|
4257 (let* ((name (ebnf-font-name font))
|
|
4258 (database (cdr (assoc name ps-font-info-database)))
|
|
4259 (size (cdr (assoc 'size database)))
|
|
4260 (base (cdr (assoc select database))))
|
|
4261 (if (and size base)
|
|
4262 (/ (* (ebnf-font-size font) base)
|
|
4263 size)
|
|
4264 (error "Invalid font: %s" name))))
|
|
4265
|
|
4266
|
|
4267 (defsubst ebnf-font-width (font)
|
|
4268 (ebnf-font-select font 'avg-char-width))
|
|
4269 (defsubst ebnf-font-height (font)
|
|
4270 (ebnf-font-select font 'line-height))
|
|
4271
|
|
4272
|
|
4273 (defun ebnf-begin-job ()
|
|
4274 (ps-printing-region nil)
|
|
4275 (if ebnf-use-float-format
|
|
4276 (setq ebnf-format-float "%1.3f"
|
|
4277 ebnf-message-float "%3.2f")
|
|
4278 (setq ebnf-format-float "%s"
|
|
4279 ebnf-message-float "%s"))
|
|
4280 (ebnf-otz-initialize)
|
|
4281 ;; to avoid compilation gripes when calling autoloaded functions
|
|
4282 (funcall (cond ((eq ebnf-syntax 'iso-ebnf)
|
|
4283 (setq ebnf-parser-func 'ebnf-iso-parser)
|
|
4284 'ebnf-iso-initialize)
|
|
4285 ((eq ebnf-syntax 'yacc)
|
|
4286 (setq ebnf-parser-func 'ebnf-yac-parser)
|
|
4287 'ebnf-yac-initialize)
|
|
4288 (t
|
|
4289 (setq ebnf-parser-func 'ebnf-bnf-parser)
|
|
4290 'ebnf-bnf-initialize)))
|
|
4291 (and ebnf-terminal-regexp ; ensures that it's a string or nil
|
|
4292 (not (stringp ebnf-terminal-regexp))
|
|
4293 (setq ebnf-terminal-regexp nil))
|
|
4294 (or (and ebnf-eps-prefix ; ensures that it's a string
|
|
4295 (stringp ebnf-eps-prefix))
|
|
4296 (setq ebnf-eps-prefix "ebnf--"))
|
|
4297 (setq ebnf-entry-percentage ; ensures value between 0.0 and 1.0
|
|
4298 (min (max ebnf-entry-percentage 0.0) 1.0)
|
|
4299 ebnf-action-list (if ebnf-horizontal-orientation
|
|
4300 '(nil keep-line)
|
|
4301 '(keep-line))
|
|
4302 ebnf-settings nil
|
|
4303 ebnf-fonts-required nil
|
|
4304 ebnf-action nil
|
|
4305 ebnf-default-p nil
|
|
4306 ebnf-eps-context nil
|
|
4307 ebnf-eps-production-list nil
|
|
4308 ebnf-eps-upper-x 0.0
|
|
4309 ebnf-eps-upper-y 0.0
|
|
4310 ebnf-font-height-P (ebnf-font-height ebnf-production-font)
|
|
4311 ebnf-font-height-T (ebnf-font-height ebnf-terminal-font)
|
|
4312 ebnf-font-height-NT (ebnf-font-height ebnf-non-terminal-font)
|
|
4313 ebnf-font-height-S (ebnf-font-height ebnf-special-font)
|
|
4314 ebnf-font-height-E (ebnf-font-height ebnf-except-font)
|
|
4315 ebnf-font-height-R (ebnf-font-height ebnf-repeat-font)
|
|
4316 ebnf-font-width-P (ebnf-font-width ebnf-production-font)
|
|
4317 ebnf-font-width-T (ebnf-font-width ebnf-terminal-font)
|
|
4318 ebnf-font-width-NT (ebnf-font-width ebnf-non-terminal-font)
|
|
4319 ebnf-font-width-S (ebnf-font-width ebnf-special-font)
|
|
4320 ebnf-font-width-E (ebnf-font-width ebnf-except-font)
|
|
4321 ebnf-font-width-R (ebnf-font-width ebnf-repeat-font)
|
|
4322 ebnf-space-T (* ebnf-font-height-T 0.5)
|
|
4323 ebnf-space-NT (* ebnf-font-height-NT 0.5)
|
|
4324 ebnf-space-S (* ebnf-font-height-S 0.5)
|
|
4325 ebnf-space-E (* ebnf-font-height-E 0.5)
|
|
4326 ebnf-space-R (* ebnf-font-height-R 0.5))
|
|
4327 (let ((basic (+ ebnf-font-height-T ebnf-font-height-NT)))
|
|
4328 (setq ebnf-basic-width (* basic 0.5)
|
|
4329 ebnf-horizontal-space (+ basic basic)
|
|
4330 ebnf-basic-height ebnf-basic-width
|
|
4331 ebnf-vertical-space ebnf-basic-width)
|
|
4332 ;; ensures value is greater than zero
|
|
4333 (or (and (numberp ebnf-production-horizontal-space)
|
|
4334 (> ebnf-production-horizontal-space 0.0))
|
|
4335 (setq ebnf-production-horizontal-space basic))
|
|
4336 ;; ensures value is greater than zero
|
|
4337 (or (and (numberp ebnf-production-vertical-space)
|
|
4338 (> ebnf-production-vertical-space 0.0))
|
|
4339 (setq ebnf-production-vertical-space basic))))
|
|
4340
|
|
4341
|
|
4342 (defsubst ebnf-shape-value (sym alist)
|
|
4343 (or (cdr (assq sym alist)) 0))
|
|
4344
|
|
4345
|
|
4346 (defsubst ebnf-boolean (value)
|
|
4347 (if value "true" "false"))
|
|
4348
|
|
4349
|
|
4350 (defun ebnf-begin-file ()
|
|
4351 (ps-flush-output)
|
|
4352 (save-excursion
|
|
4353 (set-buffer ps-spool-buffer)
|
|
4354 (goto-char (point-min))
|
|
4355 (and (search-forward "%%Creator: " nil t)
|
|
4356 (not (search-forward "& ebnf2ps v"
|
|
4357 (save-excursion (end-of-line) (point))
|
|
4358 t))
|
|
4359 (progn
|
|
4360 ;; adjust creator comment
|
|
4361 (end-of-line)
|
|
4362 (backward-char)
|
|
4363 (insert " & ebnf2ps v" ebnf-version)
|
|
4364 ;; insert ebnf settings & engine
|
|
4365 (goto-char (point-max))
|
|
4366 (search-backward "\n%%EndPrologue\n")
|
|
4367 (ebnf-insert-ebnf-prologue)
|
|
4368 (ps-output "\n")))))
|
|
4369
|
|
4370
|
|
4371 (defun ebnf-eps-finish-and-write (buffer filename)
|
|
4372 (save-excursion
|
|
4373 (set-buffer buffer)
|
|
4374 (setq ebnf-eps-upper-x (max ebnf-eps-upper-x ebnf-eps-max-width)
|
|
4375 ebnf-eps-upper-y (if (zerop ebnf-eps-upper-y)
|
|
4376 ebnf-eps-max-height
|
|
4377 (+ ebnf-eps-upper-y
|
|
4378 ebnf-production-vertical-space
|
|
4379 ebnf-eps-max-height)))
|
|
4380 ;; prologue
|
|
4381 (goto-char (point-min))
|
|
4382 (insert
|
|
4383 "%!PS-Adobe-3.0 EPSF-3.0"
|
|
4384 "\n%%BoundingBox: 0 0 "
|
|
4385 (format "%d %d" (1+ ebnf-eps-upper-x) (1+ ebnf-eps-upper-y))
|
|
4386 "\n%%Title: " filename
|
|
4387 "\n%%CreationDate: " (time-stamp-hh:mm:ss) " " (time-stamp-mon-dd-yyyy)
|
|
4388 "\n%%Creator: " (user-full-name) " (using ebnf2ps v" ebnf-version ")"
|
|
4389 "\n%%DocumentNeededResources: font "
|
|
4390 (or ebnf-fonts-required
|
|
4391 (setq ebnf-fonts-required
|
|
4392 (let ((fonts (ps-remove-duplicates
|
|
4393 (mapcar 'ebnf-font-name-select
|
|
4394 (list ebnf-production-font
|
|
4395 ebnf-terminal-font
|
|
4396 ebnf-non-terminal-font
|
|
4397 ebnf-special-font
|
|
4398 ebnf-except-font
|
|
4399 ebnf-repeat-font)))))
|
|
4400 (concat (car fonts)
|
|
4401 (and (cdr fonts) "\n%%+ font ")
|
|
4402 (mapconcat 'identity (cdr fonts) "\n%%+ font ")))))
|
|
4403 "\n%%Pages: 0\n%%EndComments\n\n%%BeginPrologue\n"
|
|
4404 ebnf-eps-prologue)
|
|
4405 (ebnf-insert-ebnf-prologue)
|
|
4406 (insert ebnf-eps-begin
|
|
4407 "\n0 " (ebnf-format-float
|
|
4408 (- ebnf-eps-upper-y (* ebnf-font-height-P 0.7)))
|
|
4409 " #ebnf2ps#begin\n")
|
|
4410 ;; epilogue
|
|
4411 (goto-char (point-max))
|
|
4412 (insert ebnf-eps-end)
|
|
4413 ;; write file
|
|
4414 (message "Saving...")
|
|
4415 (setq filename (expand-file-name filename))
|
|
4416 (let ((coding-system-for-write 'raw-text-unix))
|
|
4417 (write-region (point-min) (point-max) filename))
|
|
4418 (message "Wrote %s" filename)))
|
|
4419
|
|
4420
|
|
4421 (defun ebnf-insert-ebnf-prologue ()
|
|
4422 (insert
|
|
4423 (or ebnf-settings
|
|
4424 (setq ebnf-settings
|
|
4425 (concat
|
|
4426 "\n\n% === begin EBNF settings\n\n"
|
|
4427 ;; production
|
|
4428 (format "/fP %s /%s DefFont\n"
|
|
4429 (ebnf-format-float (ebnf-font-size ebnf-production-font))
|
|
4430 (ebnf-font-name-select ebnf-production-font))
|
|
4431 (ebnf-format-color "/ForegroundP %s def %% %s\n"
|
|
4432 (ebnf-font-foreground ebnf-production-font)
|
|
4433 "Black")
|
|
4434 (ebnf-format-color "/BackgroundP %s def %% %s\n"
|
|
4435 (ebnf-font-background ebnf-production-font)
|
|
4436 "White")
|
|
4437 (format "/EffectP %d def\n"
|
|
4438 (ebnf-font-attributes ebnf-production-font))
|
|
4439 ;; terminal
|
|
4440 (format "/fT %s /%s DefFont\n"
|
|
4441 (ebnf-format-float (ebnf-font-size ebnf-terminal-font))
|
|
4442 (ebnf-font-name-select ebnf-terminal-font))
|
|
4443 (ebnf-format-color "/ForegroundT %s def %% %s\n"
|
|
4444 (ebnf-font-foreground ebnf-terminal-font)
|
|
4445 "Black")
|
|
4446 (ebnf-format-color "/BackgroundT %s def %% %s\n"
|
|
4447 (ebnf-font-background ebnf-terminal-font)
|
|
4448 "White")
|
|
4449 (format "/EffectT %d def\n"
|
|
4450 (ebnf-font-attributes ebnf-terminal-font))
|
|
4451 (format "/BorderWidthT %s def\n"
|
|
4452 (ebnf-format-float ebnf-terminal-border-width))
|
|
4453 (ebnf-format-color "/BorderColorT %s def %% %s\n"
|
|
4454 ebnf-terminal-border-color
|
|
4455 "Black")
|
|
4456 (format "/ShapeT %d def\n"
|
|
4457 (ebnf-shape-value ebnf-terminal-shape
|
|
4458 ebnf-terminal-shape-alist))
|
|
4459 (format "/ShadowT %s def\n"
|
|
4460 (ebnf-boolean ebnf-terminal-shadow))
|
|
4461 ;; non-terminal
|
|
4462 (format "/fNT %s /%s DefFont\n"
|
|
4463 (ebnf-format-float
|
|
4464 (ebnf-font-size ebnf-non-terminal-font))
|
|
4465 (ebnf-font-name-select ebnf-non-terminal-font))
|
|
4466 (ebnf-format-color "/ForegroundNT %s def %% %s\n"
|
|
4467 (ebnf-font-foreground ebnf-non-terminal-font)
|
|
4468 "Black")
|
|
4469 (ebnf-format-color "/BackgroundNT %s def %% %s\n"
|
|
4470 (ebnf-font-background ebnf-non-terminal-font)
|
|
4471 "White")
|
|
4472 (format "/EffectNT %d def\n"
|
|
4473 (ebnf-font-attributes ebnf-non-terminal-font))
|
|
4474 (format "/BorderWidthNT %s def\n"
|
|
4475 (ebnf-format-float ebnf-non-terminal-border-width))
|
|
4476 (ebnf-format-color "/BorderColorNT %s def %% %s\n"
|
|
4477 ebnf-non-terminal-border-color
|
|
4478 "Black")
|
|
4479 (format "/ShapeNT %d def\n"
|
|
4480 (ebnf-shape-value ebnf-non-terminal-shape
|
|
4481 ebnf-terminal-shape-alist))
|
|
4482 (format "/ShadowNT %s def\n"
|
|
4483 (ebnf-boolean ebnf-non-terminal-shadow))
|
|
4484 ;; special
|
|
4485 (format "/fS %s /%s DefFont\n"
|
|
4486 (ebnf-format-float (ebnf-font-size ebnf-special-font))
|
|
4487 (ebnf-font-name-select ebnf-special-font))
|
|
4488 (ebnf-format-color "/ForegroundS %s def %% %s\n"
|
|
4489 (ebnf-font-foreground ebnf-special-font)
|
|
4490 "Black")
|
|
4491 (ebnf-format-color "/BackgroundS %s def %% %s\n"
|
|
4492 (ebnf-font-background ebnf-special-font)
|
|
4493 "Gray95")
|
|
4494 (format "/EffectS %d def\n"
|
|
4495 (ebnf-font-attributes ebnf-special-font))
|
|
4496 (format "/BorderWidthS %s def\n"
|
|
4497 (ebnf-format-float ebnf-special-border-width))
|
|
4498 (ebnf-format-color "/BorderColorS %s def %% %s\n"
|
|
4499 ebnf-special-border-color
|
|
4500 "Black")
|
|
4501 (format "/ShapeS %d def\n"
|
|
4502 (ebnf-shape-value ebnf-special-shape
|
|
4503 ebnf-terminal-shape-alist))
|
|
4504 (format "/ShadowS %s def\n"
|
|
4505 (ebnf-boolean ebnf-special-shadow))
|
|
4506 ;; except
|
|
4507 (format "/fE %s /%s DefFont\n"
|
|
4508 (ebnf-format-float (ebnf-font-size ebnf-except-font))
|
|
4509 (ebnf-font-name-select ebnf-except-font))
|
|
4510 (ebnf-format-color "/ForegroundE %s def %% %s\n"
|
|
4511 (ebnf-font-foreground ebnf-except-font)
|
|
4512 "Black")
|
|
4513 (ebnf-format-color "/BackgroundE %s def %% %s\n"
|
|
4514 (ebnf-font-background ebnf-except-font)
|
|
4515 "Gray90")
|
|
4516 (format "/EffectE %d def\n"
|
|
4517 (ebnf-font-attributes ebnf-except-font))
|
|
4518 (format "/BorderWidthE %s def\n"
|
|
4519 (ebnf-format-float ebnf-except-border-width))
|
|
4520 (ebnf-format-color "/BorderColorE %s def %% %s\n"
|
|
4521 ebnf-except-border-color
|
|
4522 "Black")
|
|
4523 (format "/ShapeE %d def\n"
|
|
4524 (ebnf-shape-value ebnf-except-shape
|
|
4525 ebnf-terminal-shape-alist))
|
|
4526 (format "/ShadowE %s def\n"
|
|
4527 (ebnf-boolean ebnf-except-shadow))
|
|
4528 ;; repeat
|
|
4529 (format "/fR %s /%s DefFont\n"
|
|
4530 (ebnf-format-float (ebnf-font-size ebnf-repeat-font))
|
|
4531 (ebnf-font-name-select ebnf-repeat-font))
|
|
4532 (ebnf-format-color "/ForegroundR %s def %% %s\n"
|
|
4533 (ebnf-font-foreground ebnf-repeat-font)
|
|
4534 "Black")
|
|
4535 (ebnf-format-color "/BackgroundR %s def %% %s\n"
|
|
4536 (ebnf-font-background ebnf-repeat-font)
|
|
4537 "Gray85")
|
|
4538 (format "/EffectR %d def\n"
|
|
4539 (ebnf-font-attributes ebnf-repeat-font))
|
|
4540 (format "/BorderWidthR %s def\n"
|
|
4541 (ebnf-format-float ebnf-repeat-border-width))
|
|
4542 (ebnf-format-color "/BorderColorR %s def %% %s\n"
|
|
4543 ebnf-repeat-border-color
|
|
4544 "Black")
|
|
4545 (format "/ShapeR %d def\n"
|
|
4546 (ebnf-shape-value ebnf-repeat-shape
|
|
4547 ebnf-terminal-shape-alist))
|
|
4548 (format "/ShadowR %s def\n"
|
|
4549 (ebnf-boolean ebnf-repeat-shadow))
|
|
4550 ;; miscellaneous
|
|
4551 (format "/DefaultWidth %s def\n"
|
|
4552 (ebnf-format-float ebnf-default-width))
|
|
4553 (format "/LineWidth %s def\n"
|
|
4554 (ebnf-format-float ebnf-line-width))
|
|
4555 (ebnf-format-color "/LineColor %s def %% %s\n"
|
|
4556 ebnf-line-color
|
|
4557 "Black")
|
|
4558 (format "/ArrowShape %d def\n"
|
|
4559 (ebnf-shape-value ebnf-arrow-shape
|
|
4560 ebnf-arrow-shape-alist))
|
|
4561 (format "/ChartShape %d def\n"
|
|
4562 (ebnf-shape-value ebnf-chart-shape
|
|
4563 ebnf-terminal-shape-alist))
|
|
4564 (format "/UserArrow{%s}def\n"
|
|
4565 (ebnf-user-arrow ebnf-user-arrow))
|
|
4566 "\n% === end EBNF settings\n\n"
|
|
4567 (and ebnf-debug-ps ebnf-debug))))
|
|
4568 ebnf-prologue))
|
|
4569
|
|
4570
|
|
4571 (defun ebnf-user-arrow (user-arrow)
|
|
4572 "Return a user arrow shape from USER-ARROW (a PostScript code).
|
|
4573
|
|
4574 This function is only called when `ebnf-arrow-shape' is set to symbol `user'.
|
|
4575
|
|
4576 If is a string, should be a PostScript procedure body.
|
|
4577 If is a variable symbol, should contain a string.
|
|
4578 If is a function symbol, it is called and the result is applied recursively.
|
|
4579 If is a cons and car is a function symbol, it is called as:
|
|
4580 (funcall (car cons) (cdr cons))
|
|
4581 and the result is applied recursively.
|
|
4582 If is a cons and car is not a function symbol, it is applied recursively on
|
|
4583 car and cdr, and the results are concatened as:
|
|
4584 (concat RESULT-FROM-CAR \" \" RESULT-FROM-CDR)
|
|
4585 If is a list and car is a function symbol, it is called as:
|
|
4586 (apply (car list) (cdr list))
|
|
4587 and the result is applied recursively.
|
|
4588 If is a list and car is not a function symbol, it is applied recursively on
|
|
4589 each element and the resulting list is concatened as:
|
|
4590 (mapconcat 'identity RESULTING-LIST \" \")
|
|
4591 Otherwise, it is treated as an empty string."
|
|
4592 (cond
|
|
4593 ((null user-arrow)
|
|
4594 "")
|
|
4595 ((stringp user-arrow)
|
|
4596 user-arrow)
|
|
4597 ((and (symbolp user-arrow) (fboundp user-arrow))
|
|
4598 (ebnf-user-arrow (funcall user-arrow)))
|
|
4599 ((and (symbolp user-arrow) (boundp user-arrow))
|
|
4600 (ebnf-user-arrow (symbol-value user-arrow)))
|
|
4601 ((consp user-arrow)
|
|
4602 (if (and (symbolp (car user-arrow)) (fboundp (car user-arrow)))
|
|
4603 (ebnf-user-arrow (funcall (car user-arrow) (cdr user-arrow)))
|
|
4604 (concat (ebnf-user-arrow (car user-arrow))
|
|
4605 " "
|
|
4606 (ebnf-user-arrow (cdr user-arrow)))))
|
|
4607 ((listp user-arrow)
|
|
4608 (if (and (symbolp (car user-arrow))
|
|
4609 (fboundp (car user-arrow)))
|
|
4610 (ebnf-user-arrow (apply (car user-arrow) (cdr user-arrow)))
|
|
4611 (mapconcat 'ebnf-user-arrow user-arrow " ")))
|
|
4612 (t
|
|
4613 "")
|
|
4614 ))
|
|
4615
|
|
4616
|
|
4617 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
4618 ;; Adjusting dimensions
|
|
4619
|
|
4620
|
|
4621 (defun ebnf-dimensions (tree)
|
|
4622 (let ((ebnf-total (length tree))
|
|
4623 (ebnf-nprod 0))
|
|
4624 (mapcar 'ebnf-production-dimension tree))
|
|
4625 tree)
|
|
4626
|
|
4627
|
|
4628 ;; [empty width-fun dim-fun entry height width]
|
|
4629 ;;(defun ebnf-empty-dimension (empty)
|
|
4630 ;; )
|
|
4631
|
|
4632
|
|
4633 ;; [production width-fun dim-fun entry height width name production action]
|
|
4634 (defun ebnf-production-dimension (production)
|
|
4635 (ebnf-message-info "Calculating dimensions")
|
|
4636 (ebnf-node-dimension-func (ebnf-node-production production))
|
|
4637 (let* ((prod (ebnf-node-production production))
|
|
4638 (height (+ ebnf-font-height-P
|
|
4639 ebnf-basic-height
|
|
4640 (ebnf-node-height prod))))
|
|
4641 (ebnf-node-entry production height)
|
|
4642 (ebnf-node-height production height)
|
|
4643 (ebnf-node-width production (+ (ebnf-node-width prod)
|
|
4644 ebnf-horizontal-space))))
|
|
4645
|
|
4646
|
|
4647 ;; [terminal width-fun dim-fun entry height width name]
|
|
4648 (defun ebnf-terminal-dimension (terminal)
|
|
4649 (ebnf-terminal-dimension1 terminal
|
|
4650 ebnf-font-height-T
|
|
4651 ebnf-font-width-T
|
|
4652 ebnf-space-T))
|
|
4653
|
|
4654
|
|
4655 ;; [non-terminal width-fun dim-fun entry height width name]
|
|
4656 (defun ebnf-non-terminal-dimension (non-terminal)
|
|
4657 (ebnf-terminal-dimension1 non-terminal
|
|
4658 ebnf-font-height-NT
|
|
4659 ebnf-font-width-NT
|
|
4660 ebnf-space-NT))
|
|
4661
|
|
4662
|
|
4663 ;; [special width-fun dim-fun entry height width name]
|
|
4664 (defun ebnf-special-dimension (special)
|
|
4665 (ebnf-terminal-dimension1 special
|
|
4666 ebnf-font-height-S
|
|
4667 ebnf-font-width-S
|
|
4668 ebnf-space-S))
|
|
4669
|
|
4670
|
|
4671 (defun ebnf-terminal-dimension1 (node font-height font-width space)
|
|
4672 (let ((height (+ space font-height space))
|
|
4673 (len (length (ebnf-node-name node))))
|
|
4674 (ebnf-node-entry node (* height 0.5))
|
|
4675 (ebnf-node-height node height)
|
|
4676 (ebnf-node-width node (+ ebnf-basic-width space
|
|
4677 (* len font-width)
|
|
4678 space ebnf-basic-width))))
|
|
4679
|
|
4680
|
|
4681 (defconst ebnf-null-vector (vector t t t 0.0 0.0 0.0))
|
|
4682
|
|
4683
|
|
4684 ;; [repeat width-fun dim-fun entry height width times element]
|
|
4685 (defun ebnf-repeat-dimension (repeat)
|
|
4686 (let ((times (ebnf-node-name repeat))
|
|
4687 (element (ebnf-node-separator repeat)))
|
|
4688 (if element
|
|
4689 (ebnf-node-dimension-func element)
|
|
4690 (setq element ebnf-null-vector))
|
|
4691 (ebnf-node-entry repeat (+ (ebnf-node-entry element)
|
|
4692 ebnf-space-R))
|
|
4693 (ebnf-node-height repeat (+ (max (ebnf-node-height element)
|
|
4694 ebnf-font-height-S)
|
|
4695 ebnf-space-R ebnf-space-R))
|
|
4696 (ebnf-node-width repeat (+ (ebnf-node-width element)
|
|
4697 ebnf-space-R ebnf-space-R ebnf-space-R
|
|
4698 ebnf-horizontal-space
|
|
4699 (* (length times) ebnf-font-width-R)))))
|
|
4700
|
|
4701
|
|
4702 ;; [except width-fun dim-fun entry height width element element]
|
|
4703 (defun ebnf-except-dimension (except)
|
|
4704 (let ((factor (ebnf-node-list except))
|
|
4705 (element (ebnf-node-separator except)))
|
|
4706 (ebnf-node-dimension-func factor)
|
|
4707 (if element
|
|
4708 (ebnf-node-dimension-func element)
|
|
4709 (setq element ebnf-null-vector))
|
|
4710 (ebnf-node-entry except (+ (max (ebnf-node-entry factor)
|
|
4711 (ebnf-node-entry element))
|
|
4712 ebnf-space-E))
|
|
4713 (ebnf-node-height except (+ (max (ebnf-node-height factor)
|
|
4714 (ebnf-node-height element))
|
|
4715 ebnf-space-E ebnf-space-E))
|
|
4716 (ebnf-node-width except (+ (ebnf-node-width factor)
|
|
4717 (ebnf-node-width element)
|
|
4718 ebnf-space-E ebnf-space-E
|
|
4719 ebnf-space-E ebnf-space-E
|
|
4720 ebnf-font-width-E
|
|
4721 ebnf-horizontal-space))))
|
|
4722
|
|
4723
|
|
4724 ;; [alternative width-fun dim-fun entry height width list]
|
|
4725 (defun ebnf-alternative-dimension (alternative)
|
|
4726 (let ((body (ebnf-node-list alternative))
|
|
4727 (lis (ebnf-node-list alternative)))
|
|
4728 (while lis
|
|
4729 (ebnf-node-dimension-func (car lis))
|
|
4730 (setq lis (cdr lis)))
|
|
4731 (let ((height 0.0)
|
|
4732 (width 0.0)
|
|
4733 (alt body)
|
|
4734 (tail (car (last body)))
|
|
4735 (entry (ebnf-node-entry (car body)))
|
|
4736 node)
|
|
4737 (while alt
|
|
4738 (setq node (car alt)
|
|
4739 alt (cdr alt)
|
|
4740 height (+ (ebnf-node-height node) height)
|
|
4741 width (max (ebnf-node-width node) width)))
|
|
4742 (ebnf-adjust-width body width)
|
|
4743 (setq height (+ height (* (1- (length body)) ebnf-vertical-space)))
|
|
4744 (ebnf-node-entry alternative (+ entry
|
|
4745 (ebnf-entry
|
|
4746 (- height entry
|
|
4747 (- (ebnf-node-height tail)
|
|
4748 (ebnf-node-entry tail))))))
|
|
4749 (ebnf-node-height alternative height)
|
|
4750 (ebnf-node-width alternative (+ width ebnf-horizontal-space))
|
|
4751 (ebnf-node-list alternative body))))
|
|
4752
|
|
4753
|
|
4754 ;; [optional width-fun dim-fun entry height width element]
|
|
4755 (defun ebnf-optional-dimension (optional)
|
|
4756 (let ((body (ebnf-node-list optional)))
|
|
4757 (ebnf-node-dimension-func body)
|
|
4758 (ebnf-node-entry optional (ebnf-node-entry body))
|
|
4759 (ebnf-node-height optional (+ (ebnf-node-height body)
|
|
4760 ebnf-vertical-space))
|
|
4761 (ebnf-node-width optional (+ (ebnf-node-width body)
|
|
4762 ebnf-horizontal-space))))
|
|
4763
|
|
4764
|
|
4765 ;; [one-or-more width-fun dim-fun entry height width element separator]
|
|
4766 (defun ebnf-one-or-more-dimension (or-more)
|
|
4767 (let ((list-part (ebnf-node-list or-more))
|
|
4768 (sep-part (ebnf-node-separator or-more)))
|
|
4769 (ebnf-node-dimension-func list-part)
|
|
4770 (and sep-part
|
|
4771 (ebnf-node-dimension-func sep-part))
|
|
4772 (let ((height (+ (if sep-part
|
|
4773 (ebnf-node-height sep-part)
|
|
4774 0.0)
|
|
4775 ebnf-vertical-space
|
|
4776 (ebnf-node-height list-part)))
|
|
4777 (width (max (if sep-part
|
|
4778 (ebnf-node-width sep-part)
|
|
4779 0.0)
|
|
4780 (ebnf-node-width list-part))))
|
|
4781 (when sep-part
|
|
4782 (ebnf-adjust-width list-part width)
|
|
4783 (ebnf-adjust-width sep-part width))
|
|
4784 (ebnf-node-entry or-more (+ (- height (ebnf-node-height list-part))
|
|
4785 (ebnf-node-entry list-part)))
|
|
4786 (ebnf-node-height or-more height)
|
|
4787 (ebnf-node-width or-more (+ width ebnf-horizontal-space)))))
|
|
4788
|
|
4789
|
|
4790 ;; [zero-or-more width-fun dim-fun entry height width element separator]
|
|
4791 (defun ebnf-zero-or-more-dimension (or-more)
|
|
4792 (let ((list-part (ebnf-node-list or-more))
|
|
4793 (sep-part (ebnf-node-separator or-more)))
|
|
4794 (ebnf-node-dimension-func list-part)
|
|
4795 (and sep-part
|
|
4796 (ebnf-node-dimension-func sep-part))
|
|
4797 (let ((height (+ (if sep-part
|
|
4798 (ebnf-node-height sep-part)
|
|
4799 0.0)
|
|
4800 ebnf-vertical-space
|
|
4801 (ebnf-node-height list-part)
|
|
4802 ebnf-vertical-space))
|
|
4803 (width (max (if sep-part
|
|
4804 (ebnf-node-width sep-part)
|
|
4805 0.0)
|
|
4806 (ebnf-node-width list-part))))
|
|
4807 (when sep-part
|
|
4808 (ebnf-adjust-width list-part width)
|
|
4809 (ebnf-adjust-width sep-part width))
|
|
4810 (ebnf-node-entry or-more height)
|
|
4811 (ebnf-node-height or-more height)
|
|
4812 (ebnf-node-width or-more (+ width ebnf-horizontal-space)))))
|
|
4813
|
|
4814
|
|
4815 ;; [sequence width-fun dim-fun entry height width list]
|
|
4816 (defun ebnf-sequence-dimension (sequence)
|
|
4817 (let ((above 0.0)
|
|
4818 (below 0.0)
|
|
4819 (width 0.0)
|
|
4820 (lis (ebnf-node-list sequence))
|
|
4821 entry node)
|
|
4822 (while lis
|
|
4823 (setq node (car lis)
|
|
4824 lis (cdr lis))
|
|
4825 (ebnf-node-dimension-func node)
|
|
4826 (setq entry (ebnf-node-entry node)
|
|
4827 above (max above entry)
|
|
4828 below (max below (- (ebnf-node-height node) entry))
|
|
4829 width (+ width (ebnf-node-width node))))
|
|
4830 (ebnf-node-entry sequence above)
|
|
4831 (ebnf-node-height sequence (+ above below))
|
|
4832 (ebnf-node-width sequence width)))
|
|
4833
|
|
4834
|
|
4835 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
4836 ;; Adjusting width
|
|
4837
|
|
4838
|
|
4839 (defun ebnf-adjust-width (node width)
|
|
4840 (cond
|
|
4841 ((listp node)
|
|
4842 (prog1
|
|
4843 node
|
|
4844 (while node
|
|
4845 (setcar node (ebnf-adjust-width (car node) width))
|
|
4846 (setq node (cdr node)))))
|
|
4847 ((vectorp node)
|
|
4848 (cond
|
|
4849 ;; nothing to be done
|
|
4850 ((= width (ebnf-node-width node))
|
|
4851 node)
|
|
4852 ;; left justify term
|
|
4853 ((eq ebnf-justify-sequence 'left)
|
|
4854 (ebnf-adjust-empty node width nil))
|
|
4855 ;; right justify terms
|
|
4856 ((eq ebnf-justify-sequence 'right)
|
|
4857 (ebnf-adjust-empty node width t))
|
|
4858 ;; centralize terms
|
|
4859 (t
|
|
4860 (ebnf-node-width-func node width)
|
|
4861 (ebnf-node-width node width)
|
|
4862 node)
|
|
4863 ))
|
|
4864 (t
|
|
4865 node)
|
|
4866 ))
|
|
4867
|
|
4868
|
|
4869 (defun ebnf-adjust-empty (node width last-p)
|
|
4870 (if (eq (ebnf-node-kind node) 'ebnf-generate-empty)
|
|
4871 (progn
|
|
4872 (ebnf-node-width node width)
|
|
4873 node)
|
|
4874 (let ((empty (ebnf-make-empty (- width (ebnf-node-width node)))))
|
|
4875 (ebnf-make-dup-sequence node
|
|
4876 (if last-p
|
|
4877 (list empty node)
|
|
4878 (list node empty))))))
|
|
4879
|
|
4880
|
|
4881 ;; [terminal width-fun dim-fun entry height width name]
|
|
4882 ;; [non-terminal width-fun dim-fun entry height width name]
|
|
4883 ;; [empty width-fun dim-fun entry height width]
|
|
4884 ;; [special width-fun dim-fun entry height width name]
|
|
4885 ;; [repeat width-fun dim-fun entry height width times element]
|
|
4886 ;; [except width-fun dim-fun entry height width element element]
|
|
4887 ;;(defun ebnf-terminal-width (terminal width)
|
|
4888 ;; )
|
|
4889
|
|
4890
|
|
4891 ;; [alternative width-fun dim-fun entry height width list]
|
|
4892 ;; [optional width-fun dim-fun entry height width element]
|
|
4893 (defun ebnf-alternative-width (alternative width)
|
|
4894 (ebnf-adjust-width (ebnf-node-list alternative)
|
|
4895 (- width ebnf-horizontal-space)))
|
|
4896
|
|
4897
|
|
4898 ;; [one-or-more width-fun dim-fun entry height width element separator]
|
|
4899 ;; [zero-or-more width-fun dim-fun entry height width element separator]
|
|
4900 (defun ebnf-list-width (or-more width)
|
|
4901 (setq width (- width ebnf-horizontal-space))
|
|
4902 (ebnf-node-list or-more
|
|
4903 (ebnf-justify-list or-more
|
|
4904 (ebnf-node-list or-more)
|
|
4905 width))
|
|
4906 (ebnf-node-separator or-more
|
|
4907 (ebnf-justify-list or-more
|
|
4908 (ebnf-node-separator or-more)
|
|
4909 width)))
|
|
4910
|
|
4911
|
|
4912 ;; [sequence width-fun dim-fun entry height width list]
|
|
4913 (defun ebnf-sequence-width (sequence width)
|
|
4914 (ebnf-node-list sequence
|
|
4915 (ebnf-justify-list sequence (ebnf-node-list sequence) width)))
|
|
4916
|
|
4917
|
|
4918 (defun ebnf-justify-list (node seq width)
|
|
4919 (let ((seq-width (ebnf-node-width node)))
|
|
4920 (if (= width seq-width)
|
|
4921 seq
|
|
4922 (cond
|
|
4923 ;; left justify terms
|
|
4924 ((eq ebnf-justify-sequence 'left)
|
|
4925 (ebnf-justify node seq seq-width width t))
|
|
4926 ;; right justify terms
|
|
4927 ((eq ebnf-justify-sequence 'right)
|
|
4928 (ebnf-justify node seq seq-width width nil))
|
|
4929 ;; centralize terms
|
|
4930 (t
|
|
4931 (let ((the-width (/ (- width seq-width) (length seq)))
|
|
4932 (lis seq))
|
|
4933 (while lis
|
|
4934 (ebnf-adjust-width (car lis)
|
|
4935 (+ (ebnf-node-width (car lis))
|
|
4936 the-width))
|
|
4937 (setq lis (cdr lis)))
|
|
4938 seq))
|
|
4939 ))))
|
|
4940
|
|
4941
|
|
4942 (defun ebnf-justify (node seq seq-width width last-p)
|
|
4943 (let ((term (car (if last-p (last seq) seq))))
|
|
4944 (cond
|
|
4945 ;; adjust empty term
|
|
4946 ((eq (ebnf-node-kind term) 'ebnf-generate-empty)
|
|
4947 (ebnf-node-width term (+ (- width seq-width)
|
|
4948 (ebnf-node-width term)))
|
|
4949 seq)
|
|
4950 ;; insert empty at end ==> left justify
|
|
4951 (last-p
|
|
4952 (nconc seq
|
|
4953 (list (ebnf-make-empty (- width seq-width)))))
|
|
4954 ;; insert empty at beginning ==> right justify
|
|
4955 (t
|
|
4956 (cons (ebnf-make-empty (- width seq-width))
|
|
4957 seq))
|
|
4958 )))
|
|
4959
|
|
4960
|
|
4961 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
4962 ;; Functions used by parsers
|
|
4963
|
|
4964
|
|
4965 (defun ebnf-eps-add-context (name)
|
|
4966 (let ((filename (ebnf-eps-filename name)))
|
|
4967 (if (member filename ebnf-eps-context)
|
|
4968 (error "Try to open an already opened EPS file: %s" filename)
|
|
4969 (setq ebnf-eps-context (cons filename ebnf-eps-context)))))
|
|
4970
|
|
4971
|
|
4972 (defun ebnf-eps-remove-context (name)
|
|
4973 (let ((filename (ebnf-eps-filename name)))
|
|
4974 (if (member filename ebnf-eps-context)
|
|
4975 (setq ebnf-eps-context (delete filename ebnf-eps-context))
|
|
4976 (error "Try to close a not opened EPS file: %s" filename))))
|
|
4977
|
|
4978
|
|
4979 (defun ebnf-eps-add-production (header)
|
|
4980 (and ebnf-eps-executing
|
|
4981 ebnf-eps-context
|
|
4982 (let ((prod (assoc header ebnf-eps-production-list)))
|
|
4983 (if prod
|
|
4984 (setcdr prod (append ebnf-eps-context (cdr prod)))
|
|
4985 (setq ebnf-eps-production-list
|
|
4986 (cons (cons header (ebnf-dup-list ebnf-eps-context))
|
|
4987 ebnf-eps-production-list))))))
|
|
4988
|
|
4989
|
|
4990 (defun ebnf-dup-list (old)
|
|
4991 (let (new)
|
|
4992 (while old
|
|
4993 (setq new (cons (car old) new)
|
|
4994 old (cdr old)))
|
|
4995 (nreverse new)))
|
|
4996
|
|
4997
|
|
4998 (defun ebnf-buffer-substring (chars)
|
|
4999 (buffer-substring-no-properties
|
|
5000 (point)
|
|
5001 (progn
|
|
5002 (skip-chars-forward chars ebnf-limit)
|
|
5003 (point))))
|
|
5004
|
|
5005
|
|
5006 (defun ebnf-string (chars eos-char kind)
|
|
5007 (forward-char)
|
|
5008 (buffer-substring-no-properties
|
|
5009 (point)
|
|
5010 (progn
|
|
5011 (skip-chars-forward (concat chars "\240-\377") ebnf-limit)
|
|
5012 (if (or (eobp) (/= (following-char) eos-char))
|
|
5013 (error "Illegal %s: missing `%c'." kind eos-char)
|
|
5014 (forward-char)
|
|
5015 (1- (point))))))
|
|
5016
|
|
5017
|
|
5018 (defun ebnf-get-string ()
|
|
5019 (forward-char)
|
|
5020 (buffer-substring-no-properties (point) (ebnf-end-of-string)))
|
|
5021
|
|
5022
|
|
5023 (defun ebnf-end-of-string ()
|
|
5024 (let ((n 1))
|
|
5025 (while (> (logand n 1) 0)
|
|
5026 (skip-chars-forward "^\"" ebnf-limit)
|
|
5027 (setq n (- (skip-chars-backward "\\\\")))
|
|
5028 (goto-char (+ (point) n 1))))
|
|
5029 (if (= (preceding-char) ?\")
|
|
5030 (1- (point))
|
|
5031 (error "Missing `\"'.")))
|
|
5032
|
|
5033
|
|
5034 (defun ebnf-trim-right (str)
|
|
5035 (let* ((len (1- (length str)))
|
|
5036 (index len))
|
|
5037 (while (and (> index 0) (= (aref str index) ?\ ))
|
|
5038 (setq index (1- index)))
|
|
5039 (if (= index len)
|
|
5040 str
|
|
5041 (substring str 0 (1+ index)))))
|
|
5042
|
|
5043
|
|
5044 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
5045 ;; Vector creation
|
|
5046
|
|
5047
|
|
5048 (defun ebnf-make-empty (&optional width)
|
|
5049 (vector 'ebnf-generate-empty
|
|
5050 'ignore
|
|
5051 'ignore
|
|
5052 0.0
|
|
5053 0.0
|
|
5054 (or width ebnf-horizontal-space)))
|
|
5055
|
|
5056
|
|
5057 (defun ebnf-make-terminal (name)
|
|
5058 (ebnf-make-terminal1 name
|
|
5059 'ebnf-generate-terminal
|
|
5060 'ebnf-terminal-dimension))
|
|
5061
|
|
5062
|
|
5063 (defun ebnf-make-non-terminal (name)
|
|
5064 (ebnf-make-terminal1 name
|
|
5065 'ebnf-generate-non-terminal
|
|
5066 'ebnf-non-terminal-dimension))
|
|
5067
|
|
5068
|
|
5069 (defun ebnf-make-special (name)
|
|
5070 (ebnf-make-terminal1 name
|
|
5071 'ebnf-generate-special
|
|
5072 'ebnf-special-dimension))
|
|
5073
|
|
5074
|
|
5075 (defun ebnf-make-terminal1 (name gen-func dim-func)
|
|
5076 (vector gen-func
|
|
5077 'ignore
|
|
5078 dim-func
|
|
5079 0.0
|
|
5080 0.0
|
|
5081 0.0
|
|
5082 (let ((len (length name)))
|
|
5083 (cond ((> len 2) name)
|
|
5084 ((= len 2) (concat " " name))
|
|
5085 ((= len 1) (concat " " name " "))
|
|
5086 (t " ")))
|
|
5087 ebnf-default-p))
|
|
5088
|
|
5089
|
|
5090 (defun ebnf-make-one-or-more (list-part &optional sep-part)
|
|
5091 (ebnf-make-or-more1 'ebnf-generate-one-or-more
|
|
5092 'ebnf-one-or-more-dimension
|
|
5093 list-part
|
|
5094 sep-part))
|
|
5095
|
|
5096
|
|
5097 (defun ebnf-make-zero-or-more (list-part &optional sep-part)
|
|
5098 (ebnf-make-or-more1 'ebnf-generate-zero-or-more
|
|
5099 'ebnf-zero-or-more-dimension
|
|
5100 list-part
|
|
5101 sep-part))
|
|
5102
|
|
5103
|
|
5104 (defun ebnf-make-or-more1 (gen-func dim-func list-part sep-part)
|
|
5105 (vector gen-func
|
|
5106 'ebnf-list-width
|
|
5107 dim-func
|
|
5108 0.0
|
|
5109 0.0
|
|
5110 0.0
|
|
5111 (if (listp list-part)
|
|
5112 (ebnf-make-sequence list-part)
|
|
5113 list-part)
|
|
5114 (if (and sep-part (listp sep-part))
|
|
5115 (ebnf-make-sequence sep-part)
|
|
5116 sep-part)))
|
|
5117
|
|
5118
|
|
5119 (defun ebnf-make-production (name prod action)
|
|
5120 (vector 'ebnf-generate-production
|
|
5121 'ignore
|
|
5122 'ebnf-production-dimension
|
|
5123 0.0
|
|
5124 0.0
|
|
5125 0.0
|
|
5126 name
|
|
5127 prod
|
|
5128 action))
|
|
5129
|
|
5130
|
|
5131 (defun ebnf-make-alternative (body)
|
|
5132 (vector 'ebnf-generate-alternative
|
|
5133 'ebnf-alternative-width
|
|
5134 'ebnf-alternative-dimension
|
|
5135 0.0
|
|
5136 0.0
|
|
5137 0.0
|
|
5138 body))
|
|
5139
|
|
5140
|
|
5141 (defun ebnf-make-optional (body)
|
|
5142 (vector 'ebnf-generate-optional
|
|
5143 'ebnf-alternative-width
|
|
5144 'ebnf-optional-dimension
|
|
5145 0.0
|
|
5146 0.0
|
|
5147 0.0
|
|
5148 body))
|
|
5149
|
|
5150
|
|
5151 (defun ebnf-make-except (factor exception)
|
|
5152 (vector 'ebnf-generate-except
|
|
5153 'ignore
|
|
5154 'ebnf-except-dimension
|
|
5155 0.0
|
|
5156 0.0
|
|
5157 0.0
|
|
5158 factor
|
|
5159 exception))
|
|
5160
|
|
5161
|
|
5162 (defun ebnf-make-repeat (times primary)
|
|
5163 (vector 'ebnf-generate-repeat
|
|
5164 'ignore
|
|
5165 'ebnf-repeat-dimension
|
|
5166 0.0
|
|
5167 0.0
|
|
5168 0.0
|
|
5169 (concat times " *")
|
|
5170 primary))
|
|
5171
|
|
5172
|
|
5173 (defun ebnf-make-sequence (seq)
|
|
5174 (vector 'ebnf-generate-sequence
|
|
5175 'ebnf-sequence-width
|
|
5176 'ebnf-sequence-dimension
|
|
5177 0.0
|
|
5178 0.0
|
|
5179 0.0
|
|
5180 seq))
|
|
5181
|
|
5182
|
|
5183 (defun ebnf-make-dup-sequence (node seq)
|
|
5184 (vector 'ebnf-generate-sequence
|
|
5185 'ebnf-sequence-width
|
|
5186 'ebnf-sequence-dimension
|
|
5187 (ebnf-node-entry node)
|
|
5188 (ebnf-node-height node)
|
|
5189 (ebnf-node-width node)
|
|
5190 seq))
|
|
5191
|
|
5192
|
|
5193 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
5194 ;; Optimizers used by parsers
|
|
5195
|
|
5196
|
|
5197 (defun ebnf-token-except (element exception)
|
|
5198 (cons (prog1
|
|
5199 (car exception)
|
|
5200 (setq exception (cdr exception)))
|
|
5201 (and element ; EMPTY - A ==> EMPTY
|
|
5202 (let ((kind (ebnf-node-kind element)))
|
|
5203 (cond
|
|
5204 ;; [ A ]- ==> A
|
|
5205 ((and (null exception)
|
|
5206 (eq kind 'ebnf-generate-optional))
|
|
5207 (ebnf-node-list element))
|
|
5208 ;; { A }- ==> { A }+
|
|
5209 ((and (null exception)
|
|
5210 (eq kind 'ebnf-generate-zero-or-more))
|
|
5211 (ebnf-node-kind element 'ebnf-generate-one-or-more)
|
|
5212 (ebnf-node-dimension-func element 'ebnf-one-or-more-dimension)
|
|
5213 element)
|
|
5214 ;; ( A | EMPTY )- ==> A
|
|
5215 ;; ( A | B | EMPTY )- ==> A | B
|
|
5216 ((and (null exception)
|
|
5217 (eq kind 'ebnf-generate-alternative)
|
|
5218 (eq (ebnf-node-kind (car (last (ebnf-node-list element))))
|
|
5219 'ebnf-generate-empty))
|
|
5220 (let ((elt (ebnf-node-list element))
|
|
5221 bef)
|
|
5222 (while (cdr elt)
|
|
5223 (setq bef elt
|
|
5224 elt (cdr elt)))
|
|
5225 (if (null bef)
|
|
5226 ;; this should not happen!!?!
|
|
5227 (setq element (ebnf-make-empty
|
|
5228 (ebnf-node-width element)))
|
|
5229 (setcdr bef nil)
|
|
5230 (setq elt (ebnf-node-list element))
|
|
5231 (and (= (length elt) 1)
|
|
5232 (setq element (car elt))))
|
|
5233 element))
|
|
5234 ;; A - B
|
|
5235 (t
|
|
5236 (ebnf-make-except element exception))
|
|
5237 )))))
|
|
5238
|
|
5239
|
|
5240 (defun ebnf-token-repeat (times repeat)
|
|
5241 (if (null (cdr repeat))
|
|
5242 ;; n * EMPTY ==> EMPTY
|
|
5243 repeat
|
|
5244 ;; n * term
|
|
5245 (cons (car repeat)
|
|
5246 (ebnf-make-repeat times (cdr repeat)))))
|
|
5247
|
|
5248
|
|
5249 (defun ebnf-token-optional (body)
|
|
5250 (let ((kind (ebnf-node-kind body)))
|
|
5251 (cond
|
|
5252 ;; [ EMPTY ] ==> EMPTY
|
|
5253 ((eq kind 'ebnf-generate-empty)
|
|
5254 nil)
|
|
5255 ;; [ { A }* ] ==> { A }*
|
|
5256 ((eq kind 'ebnf-generate-zero-or-more)
|
|
5257 body)
|
|
5258 ;; [ { A }+ ] ==> { A }*
|
|
5259 ((eq kind 'ebnf-generate-one-or-more)
|
|
5260 (ebnf-node-kind body 'ebnf-generate-zero-or-more)
|
|
5261 body)
|
|
5262 ;; [ A | B ] ==> A | B | EMPTY
|
|
5263 ((eq kind 'ebnf-generate-alternative)
|
|
5264 (ebnf-node-list body (nconc (ebnf-node-list body)
|
|
5265 (list (ebnf-make-empty))))
|
|
5266 body)
|
|
5267 ;; [ A ]
|
|
5268 (t
|
|
5269 (ebnf-make-optional body))
|
|
5270 )))
|
|
5271
|
|
5272
|
|
5273 (defun ebnf-token-alternative (body sequence)
|
|
5274 (if (null body)
|
|
5275 (if (cdr sequence)
|
|
5276 sequence
|
|
5277 (cons (car sequence)
|
|
5278 (ebnf-make-empty)))
|
|
5279 (cons (car sequence)
|
|
5280 (let ((seq (cdr sequence)))
|
|
5281 (if (and (= (length body) 1) (null seq))
|
|
5282 (car body)
|
|
5283 (ebnf-make-alternative (nreverse (if seq
|
|
5284 (cons seq body)
|
|
5285 body))))))))
|
|
5286
|
|
5287
|
|
5288 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
5289 ;; Variables used by parsers
|
|
5290
|
|
5291
|
|
5292 (defconst ebnf-comment-table
|
|
5293 (let ((table (make-vector 256 nil)))
|
|
5294 ;; Override special comment character:
|
|
5295 (aset table ?< 'newline)
|
|
5296 (aset table ?> 'keep-line)
|
|
5297 table)
|
|
5298 "Vector used to map characters to a special comment token.")
|
|
5299
|
|
5300
|
|
5301 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
5302 ;; To make this file smaller, some commands go in a separate file.
|
|
5303 ;; But autoload them here to make the separation invisible.
|
|
5304
|
|
5305 (autoload 'ebnf-bnf-parser "ebnf-bnf"
|
|
5306 "EBNF parser.")
|
|
5307
|
|
5308 (autoload 'ebnf-bnf-initialize "ebnf-bnf"
|
|
5309 "Initialize EBNF token table.")
|
|
5310
|
|
5311 (autoload 'ebnf-iso-parser "ebnf-iso"
|
|
5312 "ISO EBNF parser.")
|
|
5313
|
|
5314 (autoload 'ebnf-iso-initialize "ebnf-iso"
|
|
5315 "Initialize ISO EBNF token table.")
|
|
5316
|
|
5317 (autoload 'ebnf-yac-parser "ebnf-yac"
|
|
5318 "Yacc/Bison parser.")
|
|
5319
|
|
5320 (autoload 'ebnf-yac-initialize "ebnf-yac"
|
|
5321 "Initializations for Yacc/Bison parser.")
|
|
5322
|
|
5323 (autoload 'ebnf-eliminate-empty-rules "ebnf-otz"
|
|
5324 "Eliminate empty rules.")
|
|
5325
|
|
5326 (autoload 'ebnf-optimize "ebnf-otz"
|
|
5327 "Syntatic chart optimizer.")
|
|
5328
|
|
5329 (autoload 'ebnf-otz-initialize "ebnf-otz"
|
|
5330 "Initialize optimizer.")
|
|
5331
|
|
5332
|
|
5333 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
5334
|
|
5335
|
|
5336 (provide 'ebnf2ps)
|
|
5337
|
|
5338
|
|
5339 ;;; ebnf2ps.el ends here
|