1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
|
<TeXmacs|1.0.7.18>
<style|tmdoc>
<\body>
<tmdoc-title|Mathematical and customized input>
The <TeXmacs> meta-format allows application output to contain structured
text like mathematical formulas. In a similar way, you may use general
<TeXmacs> content as the input for your application. By default, only the
text part of such content is kept and sent to the application as a string.
Moreover, all characters in the range 0--31 are ignored, except for
<verbatim|'\\t'> and <verbatim|'\\n'> which are transformed into spaces.
There are two methods to customize the way input is sent to your
application. First of all, the configuration option
<\scm-code>
(:serializer ,<em|routine>)
</scm-code>
specifies a scheme function for converting <TeXmacs> trees to string input
for your application, thereby overriding the default method. This method
allows you for instance to treat multi-line input in a particular way or
the perform transformations on the <TeXmacs> tree.
The <scm|:serialize> option is a very powerful, but also a very abstract
way to customize input: it forces you to write a complete input
transformation function. In many circumstances, the user really wants to
rewrite two dimensional mathematical input to a more standard form, like
rewriting <no-break><math|<frac|a|b>> to <verbatim|((a)/(b))>. Therefore, a
second way for customizing the input is to use the command
<\scm-code>
\ (plugin-input-converters <em|myplugin>
\ \ \ <em|rules>)
</scm-code>
This command specifies input conversion rules for <verbatim|<em|myplugin>>
for ``mathematical input'' and reasonable defaults are provided by
<TeXmacs>. Each rule is of one of the following two forms:
<\description>
<item*|Leaf transformation rules>
Given two strings <verbatim|<em|symbol>> and <verbatim|<em|conversion>>,
the rule
<\scm-code>
(<verbatim|<em|symbol>> <verbatim|<em|conversion>>)
</scm-code>
specifies that the <TeXmacs> symbol <verbatim|<em|symbol>> should be
converted to <verbatim|<em|conversion>>.
<item*|Tag transformation rules>
Given a symbol <verbatim|<em|tag>> and a <scheme> function
<verbatim|<em|routine>>, the rule
<\scm-code>
(<em|tag> <em|routine>)
</scm-code>
specifies that <verbatim|<em|routine>> will be used as the conversion
routine for <verbatim|<em|tag>>. This routine should just write a string
to the standard output. The <scheme> function <scm|plugin-input> may be
used for the recursive transformation of the arguments of the tag.
</description>
<paragraph*|The <verbatim|input> plug-in>
The <verbatim|input> plug-in demonstrates the use of customized
mathematical input. It consists of the files
<\verbatim>
\ \ \ \ <example-plugin-link|input/Makefile>
\ \ \ \ <example-plugin-link|input/packages/session/input.ts>
\ \ \ \ <example-plugin-link|input/progs/init-input.scm>
\ \ \ \ <example-plugin-link|input/progs/input-input.scm>
\ \ \ \ <example-plugin-link|input/src/input.cpp>
</verbatim>
The <scheme> configuration code in <verbatim|init-input.scm> is given by
<\scm-code>
(plugin-configure input
\ \ (:require (url-exists-in-path? "input.bin"))
\ \ (:launch "input.bin")
\ \ (:session "Input"))
\;
(when (supports-initialize?)
\ \ (lazy-input-converter (input-input) input))
</scm-code>
The predicate <verbatim|supports-initialize?> tests whether the plug-in is
indeed operational (that is, whether <verbatim|input.bin> exists in the
path). The conversion rules in the module <verbatim|(input input)> are
added in a lazy manner. In other words, the file <verbatim|input-input.scm>
will only be loaded when we explicitly request to make a conversion. The
conversion rules in <verbatim|input-input.scm> are given by
<\scm-code>
(plugin-input-converters input
\ \ (frac input-input-frac)
\ \ (special input-input-special)
\ \ ("\<less\>vee\<gtr\>" "\|\|")
\ \ ("\<less\>wedge\<gtr\>" "&&"))
</scm-code>
This will cause <math|\<vee\>> and <math|\<wedge\>> to be rewritten as
<verbatim|\|\|> and <verbatim|&&> respectively. Fractions <math|<frac|a|b>>
are rewritten as <verbatim|((a):(b))> using the routine
<\scm-code>
(define (input-input-frac t)
\ \ (display "((")
\ \ (plugin-input (car t))
\ \ (display "):(")
\ \ (plugin-input (cadr t))
\ \ (display "))"))
</scm-code>
In the additional style file <verbatim|input.ts> we also defined some
additional markup <markup|special>:
<\tm-fragment>
<inactive*|<assign|special|<macro|body|<block|<tformat|<cwith|1|1|1|1|cell-background|pastel
green>|<table|<row|<cell|<arg|body>>>>>>>>>
</tm-fragment>
This tag is rewritten using the special conversion rule
<\scm-code>
(define (input-input-special t)
\ \ (display "[[[SPECIAL:")
\ \ (plugin-input (car t))
\ \ (display "]]]"))
</scm-code>
As to the <c++> code in <verbatim|input.cpp>, the startup banner
automatically puts the shell session in mathematical input mode:
<\cpp-code>
cout \<less\>\<less\> DATA_BEGIN \<less\>\<less\> "verbatim:";
cout \<less\>\<less\> DATA_BEGIN \<less\>\<less\>
"command:(session-use-math-input #t)"
\ \ \ \ \ \<less\>\<less\> DATA_END;
cout \<less\>\<less\> "Convert mathematical input into plain text";
cout \<less\>\<less\> DATA_END;
cout.flush ();
</cpp-code>
In the main loop, we content ourselves the reproduce the input as output:
<\cpp-code>
char buffer[100];
cin.getline (buffer, 100, '\\n');
cout \<less\>\<less\> DATA_BEGIN \<less\>\<less\> "verbatim:";
cout \<less\>\<less\> buffer;
cout \<less\>\<less\> DATA_END;
cout.flush ();
</cpp-code>
<tmdoc-copyright|1998--2002|Joris van der Hoeven>
<tmdoc-license|Permission is granted to copy, distribute and/or modify this
document under the terms of the GNU Free Documentation License, Version 1.1
or any later version published by the Free Software Foundation; with no
Invariant Sections, with no Front-Cover Texts, and with no Back-Cover
Texts. A copy of the license is included in the section entitled "GNU Free
Documentation License".>
</body>
<\initial>
<\collection>
<associate|language|english>
</collection>
</initial>
|
