helm/DEVEL/mathml_editor/src/LPushLexer.cc

   1 /* Copyright (C) 2002-2003, Luca Padovani <luca.padovani@cs.unibo.it>,
   2  *                    2003, Paolo Marinelli <pmarinel@cs.unibo.it>.
   3  *
   4  * This file is part of EdiTeX, an editor of mathematical
   5  * expressions based on TeX syntax
   6  *
   7  * EdiTeX is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11  *
  12  * EdiTeX 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
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with EdiTeX; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20  *
  21  * For details, see the EdiTeX World-Wide-Web page,
  22  * http://helm.cs.unibo.it/editex, or send a mail to
  23  * <luca.padovani@cs.unibo.it>
  24  */
  25
  26 #include "TToken.hh"
  27 #include "LPushLexer.hh"
  28 #include "APushParser.hh"
  29
  30 LPushLexer::LPushLexer(ALogger& l, APushParser& p) : APushLexer(l, p)
  31 {
  32   state = ACCEPT;
  33 }
  34
  35 void
  36 LPushLexer::reset()
  37 {
  38   buffer.erase();
  39   state = ACCEPT;
  40 }
  41
  42 void
  43 LPushLexer::flush()
  44 {
  45   push(-1);
  46 }
  47
  48 void
  49 LPushLexer::transaction(char ch, State newState)
  50 {
  51   switch (ch)
  52     {
  53     case '{': parser.push(TToken(TToken::BEGIN)); break;
  54     case '}': parser.push(TToken(TToken::END)); break;
  55     case '$': parser.push(TToken(TToken::SHIFT)); break;
  56     case '&': parser.push(TToken(TToken::ALIGN)); break;
  57     case '\n':
  58     case '\r': parser.push(TToken(TToken::EOL, ch)); break;
  59     case '^': parser.push(TToken(TToken::SUPERSCRIPT)); break;
  60     case '_': parser.push(TToken(TToken::SUBSCRIPT)); break;
  61     case '\t':
  62     case ' ': parser.push(TToken(TToken::SPACE, ch)); break;
  63     case '~': parser.push(TToken(TToken::ACTIVE, ch)); break;
  64     case '%': parser.push(TToken(TToken::COMMENT)); break;
  65     default: parser.push(TToken(TToken::OTHER, ch)); break;
  66     }
  67   state = newState;
  68 }
  69
  70 void
  71 LPushLexer::push(char ch)
  72 {
  73   switch (state)
  74     {
  75     case ACCEPT:
  76       if (ch == '\\') state = ESCAPE;
  77       else if (ch == '#') state = PARAMETER;
  78       else if (ch == -1) ;
  79       else if (isalpha(ch))
  80         {
  81           buffer.push_back(ch);
  82           state = IDENTIFIER;
  83         }
  84       else if (isspace(ch))
  85         {
  86           // we translate this space in a macro.
  87           parser.push(TToken(TToken::CONTROL, "space"));
  88         }
  89       else if (isdigit(ch))
  90         {
  91           buffer.push_back(ch);
  92           state = NUMBER;
  93         }
  94       else transaction(ch, ACCEPT);
  95       break;
  96     case ESCAPE:
  97       if (isalpha(ch))
  98         {
  99           buffer.push_back(ch);
 100           state = MACRO;
 101         }
 102       else if (ch == -1) error();
 103       else if (isdigit(ch))
 104         {
 105           // in this case, the previous '\' is ignored
 106           buffer.push_back(ch);
 107           state = NUMBER;
 108         }
 109       else
 110         {
 111           parser.push(TToken(TToken::CONTROL, ch));
 112           state = ACCEPT;
 113         }
 114       break;
 115     case MACRO:
 116       if (ch == '\\')
 117         {
 118           parser.push(TToken(TToken::CONTROL, buffer));
 119           buffer.erase();
 120           state = ESCAPE;
 121         }
 122       else if (ch == '#')
 123         {
 124           parser.push(TToken(TToken::CONTROL, buffer));
 125           buffer.erase();
 126           state = PARAMETER;
 127         }
 128       else if (isalpha(ch))
 129         buffer.push_back(ch);
 130       else if (ch == -1)
 131         {
 132           parser.push(TToken(TToken::CONTROL, buffer));
 133           buffer.erase();
 134           state = ACCEPT;
 135         }
 136       else if (isspace(ch))
 137         {
 138           parser.push(TToken(TToken::CONTROL, buffer));
 139           buffer.erase();
 140           /*
 141            * we comment this line, because a space after a macro
 142            * is useful to exit from a macro
 143           //parser.push(TToken(TToken::CONTROL, ";"));
 144           */
 145           state = ACCEPT;
 146         }
 147       else if (isdigit(ch))
 148         {
 149           parser.push(TToken(TToken::CONTROL, buffer));
 150           buffer.erase();
 151           buffer.push_back(ch);
 152           state = NUMBER;
 153         }
 154       else
 155         {
 156           parser.push(TToken(TToken::CONTROL, buffer));
 157           buffer.erase();
 158           transaction(ch, ACCEPT);
 159         }
 160       break;
 161     case PARAMETER:
 162       if (ch == -1) error();
 163       else
 164         {
 165           parser.push(TToken(TToken::PARAMETER, ch));
 166           state = ACCEPT;
 167         }
 168       break;
 169     case IDENTIFIER:
 170       if (ch == -1)
 171         {
 172           parser.push(TToken(TToken::LETTER, buffer));
 173           buffer.erase();
 174           state = ACCEPT;
 175         }
 176       else if (isalpha(ch) || isdigit(ch))
 177         {
 178           buffer.push_back(ch);
 179         }
 180       else if (isspace(ch))
 181         {
 182           parser.push(TToken(TToken::LETTER, buffer));
 183           buffer.erase();
 184           parser.push(TToken(TToken::CONTROL, "space"));
 185           state = ACCEPT;
 186         }
 187       else if (ch == '\\')
 188         {
 189           parser.push(TToken(TToken::LETTER, buffer));
 190           buffer.erase();
 191           state = ESCAPE;
 192         }
 193       else if (ch == '#')
 194         {
 195           parser.push(TToken(TToken::LETTER, buffer));
 196           buffer.erase();
 197           state = PARAMETER;
 198         }
 199       else
 200         {
 201           parser.push(TToken(TToken::LETTER, buffer));
 202           buffer.erase();
 203           transaction(ch, ACCEPT);
 204         }
 205       break;
 206     case NUMBER:
 207       if (isdigit(ch)) buffer.push_back(ch);
 208       else if (isspace(ch))
 209         {
 210           parser.push(TToken(TToken::DIGIT, buffer));
 211           buffer.erase();
 212           parser.push(TToken(TToken::CONTROL, "space"));
 213           state = ACCEPT;
 214         }
 215       else if (isalpha(ch))
 216         {
 217           parser.push(TToken(TToken::DIGIT, buffer));
 218           buffer.erase();
 219           buffer.push_back(ch);
 220           state = IDENTIFIER;
 221         }
 222       else if (ch == -1)
 223         {
 224           parser.push(TToken(TToken::DIGIT, buffer));
 225           buffer.erase();
 226           state = ACCEPT;
 227         }
 228       else if (ch == '\\')
 229         {
 230           parser.push(TToken(TToken::DIGIT, buffer));
 231           buffer.erase();
 232           state = ESCAPE;
 233         }
 234       else if (ch == '#')
 235         {
 236           parser.push(TToken(TToken::DIGIT, buffer));
 237           buffer.erase();
 238           state = PARAMETER;
 239         }
 240       else
 241         {
 242           parser.push(TToken(TToken::DIGIT, buffer));
 243           buffer.erase();
 244           transaction(ch, ACCEPT);
 245         }
 246       break;
 247     default:
 248       assert(0);
 249       break;
 250     }
 251
 252   switch (state)
 253     {
 254     case ESCAPE: parser.setCursorHint("\\"); break;
 255     case MACRO: parser.setCursorHint("\\" + buffer); break;
 256     case PARAMETER: parser.setCursorHint("#"); break;
 257     case IDENTIFIER: parser.setCursorHint(buffer); break;
 258     case NUMBER: parser.setCursorHint(buffer); break;
 259     default: parser.setCursorHint(""); break;
 260     }
 261 }
 262
 263 void
 264 LPushLexer::drop(bool alt)
 265 {
 266   std::string restore = "";
 267
 268   switch (state)
 269     {
 270     case ACCEPT:
 271       restore = parser.drop(alt);
 272       if (restore.length() > 0 && restore[0] == '\\')
 273         {
 274           cout << restore << endl;
 275           buffer = std::string(restore, 1, restore.length() - 1);
 276           state = (buffer.length() > 0) ? MACRO : ESCAPE;
 277         }
 278       else if (restore.length() > 0 && isdigit(restore[0]))
 279         {
 280           buffer = restore;
 281           state = NUMBER;
 282         }
 283       else if (restore.length() > 0 && isalpha(restore[0]))
 284         {
 285           buffer = restore;
 286           state = IDENTIFIER;
 287         }
 288       break;
 289     case ESCAPE:
 290       state = ACCEPT;
 291       break;
 292     case MACRO:
 293       if (alt) buffer.erase();
 294       else buffer.erase(buffer.length() - 1, 1);
 295       if (buffer.length() == 0) state = ESCAPE;
 296       break;
 297     case IDENTIFIER:
 298       if (alt) buffer.erase();
 299       else buffer.erase(buffer.length() - 1, 1);
 300       if (buffer.length() == 0) state = ACCEPT;
 301       break;
 302     case NUMBER:
 303       if (alt) buffer.erase();
 304       else buffer.erase(buffer.length() - 1, 1);
 305       if (buffer.length() == 0) state = ACCEPT;
 306       break;
 307     case PARAMETER:
 308     default:
 309       //assert(0);
 310       error();
 311       break;
 312     }
 313
 314   switch (state)
 315     {
 316     case ESCAPE: parser.setCursorHint("\\"); break;
 317     case MACRO: parser.setCursorHint("\\" + buffer); break;
 318     case PARAMETER: parser.setCursorHint("#"); break;
 319     case IDENTIFIER: parser.setCursorHint(buffer); break;
 320     case NUMBER: parser.setCursorHint(buffer); break;
 321     default: parser.setCursorHint(""); break;
 322     }
 323 }
 324
 325 bool
 326 LPushLexer::error() const
 327 {
 328   return false;
 329 }