]> matita.cs.unibo.it Git - helm.git/blob - helm/DEVEL/mathml_editor/src/LPushLexer.cc
Bug fixed: wrong exception was raised (instead of returning false)
[helm.git] / helm / DEVEL / mathml_editor / src / LPushLexer.cc
1 /* This file is part of EdiTeX, an editor of mathematical
2  * expressions based on TeX syntax.
3  * 
4  * Copyright (C) 2002-2003 Luca Padovani <lpadovan@cs.unibo.it>,
5  *                    2003 Paolo Marinelli <pmarinel@cs.unibo.it>.
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20  *
21  * For more information, please visit the project's home page
22  * http://helm.cs.unibo.it/editex/
23  * or send an email to <lpadovan@cs.unibo.it>
24  */
25
26 #include <string>
27 #include <cctype>
28 #include <cassert>
29
30 #include "ALogger.hh"
31 #include "TToken.hh"
32 #include "LPushLexer.hh"
33 #include "APushParser.hh"
34
35 LPushLexer::LPushLexer(ALogger& l, APushParser& p) : APushLexer(l, p)
36 {
37   state = ACCEPT;
38 }
39
40 void
41 LPushLexer::reset()
42 {
43   buffer.erase();
44   state = ACCEPT;
45
46   displayCursor();
47 }
48
49 void
50 LPushLexer::flush()
51 {
52   push(-1);
53 }
54
55 void
56 LPushLexer::transaction(char ch, State newState)
57 {
58   switch (ch)
59     {
60     case '{': parser.push(TToken(TToken::BEGIN)); break;
61     case '}': parser.push(TToken(TToken::END)); break;
62     case '$': parser.push(TToken(TToken::SHIFT)); break;
63     case '&': parser.push(TToken(TToken::ALIGN)); break;
64     case '\n':
65     case '\r': parser.push(TToken(TToken::EOL, ch)); break;
66     case '^': parser.push(TToken(TToken::SUPERSCRIPT)); break;
67     case '_': parser.push(TToken(TToken::SUBSCRIPT)); break;
68     case '\t': parser.push(TToken(TToken::IGNORABLE_SPACE, ch)); break;
69     case ' ': parser.push(TToken(TToken::SPACE, ch)); break;
70     case '~': parser.push(TToken(TToken::ACTIVE, ch)); break;
71     case '%': parser.push(TToken(TToken::COMMENT)); break;     
72     default: parser.push(TToken(TToken::OTHER, ch)); break;
73     }
74   state = newState;
75 }
76
77 void
78 LPushLexer::push(char ch)
79 {
80   switch (state)
81     {
82     case ACCEPT:
83       if (ch == '\\') state = ESCAPE;
84       else if (ch == '#') state = PARAMETER;
85       else if (ch == -1) ;
86       else if (isalpha(ch))
87         {
88           buffer.push_back(ch);
89           state = IDENTIFIER;
90         }
91       else if (isdigit(ch))
92         {
93           buffer.push_back(ch);
94           state = NUMBER;
95         }
96       else transaction(ch, ACCEPT);
97       break;
98     case ESCAPE:
99       if (isalpha(ch))
100         {
101           buffer.push_back(ch);
102           state = MACRO;
103         }
104       else if (ch == -1) error();
105       else if (isdigit(ch))
106         {
107           // in this case, the previous '\' is ignored
108           buffer.push_back(ch);
109           state = NUMBER;
110         }
111       else
112         {
113           parser.push(TToken(TToken::CONTROL, ch));
114           state = ACCEPT;
115         }
116       break;
117     case MACRO:
118       if (ch == '\\')
119         {
120           parser.push(TToken(TToken::CONTROL, buffer));
121           buffer.erase();
122           state = ESCAPE;
123         }
124       else if (ch == '#')
125         {
126           parser.push(TToken(TToken::CONTROL, buffer));
127           buffer.erase();
128           state = PARAMETER;
129         }
130       else if (isalpha(ch))
131         buffer.push_back(ch);
132       else if (ch == -1)
133         {
134           parser.push(TToken(TToken::CONTROL, buffer));
135           buffer.erase();
136           state = ACCEPT;
137         }
138       else if (isspace(ch))
139           {
140             // we don't call transaction, because a white space is useful to exit from the macro,
141             // without "side effect". It's the TeX syntax.
142             parser.push(TToken(TToken::CONTROL, buffer));
143             buffer.erase();
144             state = ACCEPT;
145         }
146       else if (isdigit(ch))
147         {
148           parser.push(TToken(TToken::CONTROL, buffer));
149           buffer.erase();
150           buffer.push_back(ch);
151           state = NUMBER;
152         }
153       else
154         {
155           parser.push(TToken(TToken::CONTROL, buffer));
156           buffer.erase();
157           transaction(ch, ACCEPT);
158         }
159       break;
160     case PARAMETER:
161       if (ch == -1) error();
162       else
163         {
164           parser.push(TToken(TToken::PARAMETER, ch));
165           state = ACCEPT;
166         }
167       break;
168     case IDENTIFIER:
169       if (ch == -1)
170         {
171           parser.push(TToken(TToken::LETTER, buffer));
172           buffer.erase();
173           state = ACCEPT;
174         }
175       else if (isalpha(ch) || isdigit(ch))
176         {
177           buffer.push_back(ch);
178         }
179       else if (ch == '\\') state = ESCAPED_CHARACTER;
180       else if (ch == '#')
181         {
182           parser.push(TToken(TToken::LETTER, buffer));
183           buffer.erase();
184           state = PARAMETER;
185         }
186       else
187         {
188           parser.push(TToken(TToken::LETTER, buffer));
189           buffer.erase();
190           transaction(ch, ACCEPT);
191         }
192       break;
193     case ESCAPED_CHARACTER:
194       if ((ch == '-') || (ch == '_') || (ch == '/'))
195         {
196           buffer.push_back(ch);
197           state = IDENTIFIER;
198         }
199       else if (isalpha(ch))
200         {
201           parser.push(TToken(TToken::LETTER, buffer));
202           buffer.erase();
203           buffer.push_back(ch);
204           state = MACRO;
205         }
206       else if (ch == -1) error();
207       else if (isdigit(ch))
208         {
209           parser.push(TToken(TToken::LETTER, buffer));
210           buffer.erase();
211           buffer.push_back(ch);
212           state = NUMBER;
213         }
214       else
215         {
216           parser.push(TToken(TToken::LETTER, buffer));
217           buffer.erase();
218           parser.push(TToken(TToken::CONTROL, ch));
219           state = ACCEPT;
220         }
221       break;
222     case NUMBER:
223       if (isdigit(ch)) buffer.push_back(ch);
224       else if (isalpha(ch))
225         {
226           parser.push(TToken(TToken::DIGIT, buffer));
227           buffer.erase();
228           buffer.push_back(ch);
229           state = IDENTIFIER;
230         }
231       else if (ch == -1)
232         {
233           parser.push(TToken(TToken::DIGIT, buffer));
234           buffer.erase();
235           state = ACCEPT;
236         }
237       else if (ch == '\\')
238         {
239           parser.push(TToken(TToken::DIGIT, buffer));
240           buffer.erase();
241           state = ESCAPE;
242         }
243       else if (ch == '#')
244         {
245           parser.push(TToken(TToken::DIGIT, buffer));
246           buffer.erase();
247           state = PARAMETER;
248         }
249       else
250         {
251           parser.push(TToken(TToken::DIGIT, buffer));
252           buffer.erase();
253           transaction(ch, ACCEPT);
254         }
255       break;
256     default:
257       assert(0);
258       break;
259     }
260
261   displayCursor();
262
263 }
264
265 void
266 LPushLexer::drop(bool alt)
267 {
268   std::string restore = "";
269
270   switch (state)
271     {
272     case ACCEPT:
273       {
274         restore = parser.drop(alt);
275         long bs_pos = restore.find('\\');
276         if ((restore.length() > 0) && (bs_pos != std::string::npos))
277           {
278             // in this case we have to control the blackslash's position
279             if (bs_pos == 0)
280               {
281                 //logger.debug(restore);
282                 buffer = std::string(restore, 1, restore.length() - 1);
283                 state = (buffer.length() > 0) ? MACRO : ESCAPE;
284               }
285             else
286               {
287                 assert(bs_pos == restore.length() - 1);
288                 buffer = std::string(restore, 0, bs_pos);
289                 state = ESCAPED_CHARACTER;
290               }
291           }
292         else if (restore.length() > 0 && isdigit(restore[0]))
293           {
294             buffer = restore;
295             state = NUMBER;
296           }
297         else if (restore.length() > 0 && isalpha(restore[0]))
298           {
299             buffer = restore;
300             state = IDENTIFIER;
301           }
302       }
303       break;
304 /*      if (restore.length() > 0 && restore[0] == '\\')
305         {
306           logger.debug(restore);
307           buffer = std::string(restore, 1, restore.length() - 1);
308           state = (buffer.length() > 0) ? MACRO : ESCAPE;
309         }
310       else if (restore.length() > 0 && isdigit(restore[0]))
311         {
312           buffer = restore;
313           state = NUMBER;
314         }
315       else if (restore.length() > 0 && isalpha(restore[0]))
316         {
317           buffer = restore;
318           state = IDENTIFIER;
319         }
320       break;*/
321     case ESCAPED_CHARACTER:
322       state = IDENTIFIER;
323       break;
324     case ESCAPE:
325       state = ACCEPT;
326       break;
327     case MACRO:
328       if (alt) buffer.erase();
329       else buffer.erase(buffer.length() - 1, 1);
330       if (buffer.length() == 0) state = ESCAPE;
331       break;
332     case IDENTIFIER:
333       switch (buffer[buffer.length() - 1])
334         {
335         case '-':
336         case '_':
337           buffer.erase(buffer.length() - 1, 1);
338           if (alt) state = ESCAPED_CHARACTER;
339           break;
340         default:
341           if (alt) buffer.erase(); 
342           else buffer.erase(buffer.length() - 1, 1);
343           if (buffer.length() == 0) state = ACCEPT;
344           break;
345         }
346       break;
347     case NUMBER:
348       if (alt) buffer.erase();
349       else buffer.erase(buffer.length() - 1, 1);
350       if (buffer.length() == 0) state = ACCEPT;
351       break;
352     case PARAMETER:
353     default:
354       //assert(0);
355       error();
356       break;
357     }
358
359   displayCursor();
360
361 }
362
363 void
364 LPushLexer::displayCursor()
365 {
366   switch (state)
367     {
368     case ESCAPE: parser.setCursorHint("\\"); break;
369     case ESCAPED_CHARACTER: parser.setCursorHint(buffer + "\\"); break;
370     case MACRO: parser.setCursorHint("\\" + buffer); break;
371     case PARAMETER: parser.setCursorHint("#"); break;
372     case IDENTIFIER: parser.setCursorHint(buffer); break;
373     case NUMBER: parser.setCursorHint(buffer); break;
374     default: parser.setCursorHint(""); break;
375     }
376 }
377
378 bool
379 LPushLexer::error() const
380 {
381   return false;
382 }