misc/mediasource/extra/netradiant-src/libs/script/scripttokeniser.h

   1 /*
   2 Copyright (C) 2001-2006, William Joseph.
   3 All Rights Reserved.
   4
   5 This file is part of GtkRadiant.
   6
   7 GtkRadiant is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 GtkRadiant 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 GtkRadiant; if not, write to the Free Software
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20 */
  21
  22 #if !defined(INCLUDED_SCRIPT_SCRIPTTOKENISER_H)
  23 #define INCLUDED_SCRIPT_SCRIPTTOKENISER_H
  24
  25 #include "iscriplib.h"
  26
  27 class ScriptTokeniser : public Tokeniser
  28 {
  29   enum CharType
  30   {
  31     eWhitespace,
  32     eCharToken,
  33     eNewline,
  34     eCharQuote,
  35     eCharSolidus,
  36     eCharStar,
  37     eCharSpecial,
  38   };
  39
  40   typedef bool (ScriptTokeniser::*Tokenise)(char c);
  41
  42   Tokenise m_stack[3];
  43   Tokenise* m_state;
  44   SingleCharacterInputStream<TextInputStream> m_istream;
  45   std::size_t m_scriptline;
  46   std::size_t m_scriptcolumn;
  47
  48   char m_token[MAXTOKEN];
  49   char* m_write;
  50
  51   char m_current;
  52   bool m_eof;
  53   bool m_crossline;
  54   bool m_unget;
  55   bool m_emit;
  56
  57   bool m_special;
  58
  59   CharType charType(const char c)
  60   {
  61     switch(c)
  62     {
  63     case '\n': return eNewline;
  64     case '"': return eCharQuote;
  65     case '/': return eCharSolidus;
  66     case '*': return eCharStar;
  67     case '{': case '(': case '}': case ')': case '[': case ']': case ',': case ':': return (m_special) ? eCharSpecial : eCharToken;
  68     }
  69
  70     if(c > 32)
  71     {
  72       return eCharToken;
  73     }
  74     return eWhitespace;
  75   }
  76
  77   Tokenise state()
  78   {
  79     return *m_state;
  80   }
  81   void push(Tokenise state)
  82   {
  83     ASSERT_MESSAGE(m_state != m_stack + 2, "token parser: illegal stack push");
  84     *(++m_state) = state;
  85   }
  86   void pop()
  87   {
  88     ASSERT_MESSAGE(m_state != m_stack, "token parser: illegal stack pop");
  89     --m_state;
  90   }
  91   void add(const char c)
  92   {
  93     if(m_write < m_token + MAXTOKEN - 1)
  94     {
  95       *m_write++ = c;
  96     }
  97   }
  98   void remove()
  99   {
 100     ASSERT_MESSAGE(m_write > m_token, "no char to remove");
 101     --m_write;
 102   }
 103
 104   bool tokeniseDefault(char c)
 105   {
 106     switch(charType(c))
 107     {
 108     case eNewline:
 109       if(!m_crossline)
 110       {
 111         globalErrorStream() << Unsigned(getLine()) << ":" << Unsigned(getColumn()) << ": unexpected end-of-line before token\n";
 112         return false;
 113       }
 114       break;
 115     case eCharToken:
 116     case eCharStar:
 117       push(Tokenise(&ScriptTokeniser::tokeniseToken));
 118       add(c);
 119       break;
 120     case eCharSpecial:
 121       push(Tokenise(&ScriptTokeniser::tokeniseSpecial));
 122       add(c);
 123       break;
 124     case eCharQuote:
 125       push(Tokenise(&ScriptTokeniser::tokeniseQuotedToken));
 126       break;
 127     case eCharSolidus:
 128       push(Tokenise(&ScriptTokeniser::tokeniseSolidus));
 129       break;
 130     default:
 131       break;
 132     }
 133     return true;
 134   }
 135   bool tokeniseToken(char c)
 136   {
 137     switch(charType(c))
 138     {
 139     case eNewline:
 140     case eWhitespace:
 141     case eCharQuote:
 142     case eCharSpecial:
 143       pop();
 144       m_emit = true; // emit token
 145       break;
 146     case eCharSolidus:
 147 #if 0 //SPoG: ignore comments in the middle of tokens.
 148       push(Tokenise(&ScriptTokeniser::tokeniseSolidus));
 149       break;
 150 #endif
 151     case eCharToken:
 152     case eCharStar:
 153       add(c);
 154       break;
 155     default:
 156       break;
 157     }
 158     return true;
 159   }
 160   bool tokeniseQuotedToken(char c)
 161   {
 162     switch(charType(c))
 163     {
 164     case eNewline:
 165       if(m_crossline)
 166       {
 167         globalErrorStream() << Unsigned(getLine()) << ":" << Unsigned(getColumn()) << ": unexpected end-of-line in quoted token\n";
 168         return false;
 169       }
 170       break;
 171     case eWhitespace:
 172     case eCharToken:
 173     case eCharSolidus:
 174     case eCharStar:
 175     case eCharSpecial:
 176       add(c);
 177       break;
 178     case eCharQuote:
 179       pop();
 180       push(Tokenise(&ScriptTokeniser::tokeniseEndQuote));
 181       break;
 182     default:
 183       break;
 184     }
 185     return true;
 186   }
 187   bool tokeniseSolidus(char c)
 188   {
 189     switch(charType(c))
 190     {
 191     case eNewline:
 192     case eWhitespace:
 193     case eCharQuote:
 194     case eCharSpecial:
 195       pop();
 196       add('/');
 197       m_emit = true; // emit single slash
 198       break;
 199     case eCharToken:
 200       pop();
 201       add('/');
 202       add(c);
 203       break;
 204     case eCharSolidus:
 205       pop();
 206       push(Tokenise(&ScriptTokeniser::tokeniseComment));
 207       break; // dont emit single slash
 208     case eCharStar:
 209       pop();
 210       push(Tokenise(&ScriptTokeniser::tokeniseBlockComment));
 211       break; // dont emit single slash
 212     default:
 213       break;
 214     }
 215     return true;
 216   }
 217   bool tokeniseComment(char c)
 218   {
 219     if(c == '\n')
 220     {
 221       pop();
 222       if(state() == Tokenise(&ScriptTokeniser::tokeniseToken))
 223       {
 224         pop();
 225         m_emit = true; // emit token immediatly preceding comment
 226       }
 227     }
 228     return true;
 229   }
 230   bool tokeniseBlockComment(char c)
 231   {
 232     if(c == '*')
 233     {
 234       pop();
 235       push(Tokenise(&ScriptTokeniser::tokeniseEndBlockComment));
 236     }
 237     return true;
 238   }
 239   bool tokeniseEndBlockComment(char c)
 240   {
 241     switch(c)
 242     {
 243     case '/':
 244       pop();
 245       if(state() == Tokenise(&ScriptTokeniser::tokeniseToken))
 246       {
 247         pop();
 248         m_emit = true; // emit token immediatly preceding comment
 249       }
 250       break; // dont emit comment
 251     case '*':
 252       break; // no state change
 253     default:
 254       pop();
 255       push(Tokenise(&ScriptTokeniser::tokeniseBlockComment));
 256       break;
 257     }
 258     return true;
 259   }
 260   bool tokeniseEndQuote(char c)
 261   {
 262     pop();
 263     m_emit = true; // emit quoted token
 264     return true;
 265   }
 266   bool tokeniseSpecial(char c)
 267   {
 268     pop();
 269     m_emit = true; // emit single-character token
 270     return true;
 271   }
 272
 273   /// Returns true if a token was successfully parsed.
 274   bool tokenise()
 275   {
 276     m_write = m_token;
 277     while(!eof())
 278     {
 279       char c = m_current;
 280
 281       if(!((*this).*state())(c))
 282       {
 283         // parse error
 284         m_eof = true;
 285         return false;
 286       }
 287       if(m_emit)
 288       {
 289         m_emit = false;
 290         return true;
 291       }
 292
 293       if(c == '\n')
 294       {
 295         ++m_scriptline;
 296         m_scriptcolumn = 1;
 297       }
 298       else
 299       {
 300         ++m_scriptcolumn;
 301       }
 302
 303       m_eof = !m_istream.readChar(m_current);
 304     }
 305     return m_write != m_token;
 306   }
 307
 308   const char* fillToken()
 309   {
 310     if(!tokenise())
 311     {
 312       return 0;
 313     }
 314
 315     add('\0');
 316     return m_token;
 317   }
 318
 319   bool eof()
 320   {
 321     return m_eof;
 322   }
 323
 324 public:
 325   ScriptTokeniser(TextInputStream& istream, bool special)
 326     : m_state(m_stack),
 327     m_istream(istream),
 328     m_scriptline(1),
 329     m_scriptcolumn(1),
 330     m_crossline(false),
 331     m_unget(false),
 332     m_emit(false),
 333     m_special(special)
 334   {
 335     m_stack[0] = Tokenise(&ScriptTokeniser::tokeniseDefault);
 336     m_eof = !m_istream.readChar(m_current);
 337     m_token[MAXTOKEN - 1] = '\0';
 338   }
 339   void release()
 340   {
 341     delete this;
 342   }
 343   void nextLine()
 344   {
 345     m_crossline = true;
 346   }
 347   const char* getToken()
 348   {
 349     if(m_unget)
 350     {
 351       m_unget = false;
 352       return m_token;
 353     }
 354
 355     return fillToken();
 356   }
 357   void ungetToken()
 358   {
 359     ASSERT_MESSAGE(!m_unget, "can't unget more than one token");
 360     m_unget = true;
 361   }
 362   std::size_t getLine() const
 363   {
 364     return m_scriptline;
 365   }
 366   std::size_t getColumn() const
 367   {
 368     return m_scriptcolumn;
 369   }
 370 };
 371
 372
 373 inline Tokeniser& NewScriptTokeniser(TextInputStream& istream)
 374 {
 375   return *(new ScriptTokeniser(istream, true));
 376 }
 377
 378 inline Tokeniser& NewSimpleTokeniser(TextInputStream& istream)
 379 {
 380   return *(new ScriptTokeniser(istream, false));
 381 }
 382
 383 #endif