java/demo/Freeze/library/Scanner.java

   1 // **********************************************************************
   2 //
   3 // Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   4 //
   5 // This copy of Ice is licensed to you under the terms described in the
   6 // ICE_LICENSE file included in this distribution.
   7 //
   8 // **********************************************************************
   9
  10 class Scanner
  11 {
  12     Scanner(Parser p)
  13     {
  14         _parser = p;
  15     }
  16
  17     Token
  18     nextToken()
  19     {
  20         String s = next();
  21         if(s == null)
  22         {
  23             return null;
  24         }
  25
  26         if(s.equals(";"))
  27         {
  28             return new Token(Token.TOK_SEMI);
  29         }
  30         else if(s.equals("help"))
  31         {
  32             return new Token(Token.TOK_HELP);
  33         }
  34         else if(s.equals("exit") || s.equals("quit"))
  35         {
  36             return new Token(Token.TOK_EXIT);
  37         }
  38         else if(s.equals("add"))
  39         {
  40             return new Token(Token.TOK_ADD_BOOK);
  41         }
  42         else if(s.equals("isbn"))
  43         {
  44             return new Token(Token.TOK_FIND_ISBN);
  45         }
  46         else if(s.equals("authors"))
  47         {
  48             return new Token(Token.TOK_FIND_AUTHORS);
  49         }
  50         else if(s.equals("next"))
  51         {
  52             return new Token(Token.TOK_NEXT_FOUND_BOOK);
  53         }
  54         else if(s.equals("current"))
  55         {
  56             return new Token(Token.TOK_PRINT_CURRENT);
  57         }
  58         else if(s.equals("rent"))
  59         {
  60             return new Token(Token.TOK_RENT_BOOK);
  61         }
  62         else if(s.equals("return"))
  63         {
  64             return new Token(Token.TOK_RETURN_BOOK);
  65         }
  66         else if(s.equals("remove"))
  67         {
  68             return new Token(Token.TOK_REMOVE_CURRENT);
  69         }
  70         else if(s.equals("size"))
  71         {
  72             return new Token(Token.TOK_SET_EVICTOR_SIZE);
  73         }
  74         else if(s.equals("shutdown"))
  75         {
  76             return new Token(Token.TOK_SHUTDOWN);
  77         }
  78         else
  79         {
  80             return new Token(Token.TOK_STRING, s);
  81         }
  82     }
  83
  84     static private class EndOfInput extends Exception
  85     {
  86     }
  87
  88     private char
  89     get()
  90         throws EndOfInput
  91     {
  92         //
  93         // If there is an character in the unget buffer, return it.
  94         //
  95         if(_unget)
  96         {
  97             _unget = false;
  98             return _ungetChar;
  99         }
 100
 101         //
 102         // No current buffer?
 103         //
 104         if(_buf == null)
 105         {
 106             _buf = _parser.getInput();
 107             _pos = 0;
 108             if(_buf == null)
 109             {
 110                 throw new EndOfInput();
 111             }
 112         }
 113
 114         //
 115         // At the end-of-buffer?
 116         //
 117         while(_pos >= _buf.length())
 118         {
 119             _buf = null;
 120             _pos = 0;
 121             return '\n';
 122         }
 123
 124         return _buf.charAt(_pos++);
 125     }
 126
 127     //
 128     // unget only works with one character.
 129     //
 130     private void
 131     unget(char c)
 132     {
 133         assert(!_unget);
 134         _unget = true;
 135         _ungetChar = c;
 136     }
 137
 138     private String
 139     next()
 140     {
 141         //
 142         // Eat any whitespace.
 143         //
 144         char c;
 145         try
 146         {
 147             do
 148             {
 149                 c = get();
 150             }
 151             while(Character.isWhitespace(c) && c != '\n');
 152         }
 153         catch(EndOfInput ignore)
 154         {
 155             return null;
 156         }
 157
 158         StringBuilder buf = new StringBuilder(128);
 159
 160         if(c == ';' || c == '\n')
 161         {
 162             buf.append(';');
 163         }
 164         else if(c == '\'')
 165         {
 166             try
 167             {
 168                 while(true)
 169                 {
 170                     c = get();
 171                     if(c == '\'')
 172                     {
 173                         break;
 174                     }
 175                     else
 176                     {
 177                         buf.append(c);
 178                     }
 179                 }
 180             }
 181             catch(EndOfInput e)
 182             {
 183                 _parser.warning("EOF in string");
 184             }
 185         }
 186         else if(c == '\"')
 187         {
 188             try
 189             {
 190                 while(true)
 191                 {
 192                     c = get();
 193                     if(c == '\"')
 194                     {
 195                         break;
 196                     }
 197                     else if(c == '\\')
 198                     {
 199                         try
 200                         {
 201                             char next = get();
 202                             switch(next)
 203                             {
 204                                 case '\\':
 205                                 case '"':
 206                                 {
 207                                     buf.append(next);
 208                                     break;
 209                                 }
 210
 211                                 case 'n':
 212                                 {
 213                                     buf.append('\n');
 214                                     break;
 215                                 }
 216
 217                                 case 'r':
 218                                 {
 219                                     buf.append('\r');
 220                                     break;
 221                                 }
 222
 223                                 case 't':
 224                                 {
 225                                     buf.append('\t');
 226                                     break;
 227                                 }
 228
 229                                 case 'f':
 230                                 {
 231                                     buf.append('\f');
 232                                     break;
 233                                 }
 234
 235                                 default:
 236                                 {
 237                                     buf.append(c);
 238                                     unget(next);
 239                                 }
 240                             }
 241                         }
 242                         catch(EndOfInput e)
 243                         {
 244                             buf.append(c);
 245                         }
 246                     }
 247                     else
 248                     {
 249                         buf.append(c);
 250                     }
 251                 }
 252             }
 253             catch(EndOfInput e)
 254             {
 255                 _parser.warning("EOF in string");
 256             }
 257         }
 258         else
 259         {
 260             //
 261             // Otherwise it's a string.
 262             //
 263             try
 264             {
 265                 do
 266                 {
 267                     buf.append(c);
 268                     c = get();
 269                 }
 270                 while(!Character.isWhitespace(c) && c != ';' && c != '\n');
 271
 272                 unget(c);
 273             }
 274             catch(EndOfInput ignore)
 275             {
 276             }
 277         }
 278
 279         return buf.toString();
 280     }
 281
 282     private Parser _parser;
 283     private boolean _unget = false;
 284     private char _ungetChar;
 285     private String _buf = null;
 286     private int _pos;
 287 }