1 /* 2 * Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. 3 * Use of this file is governed by the BSD 3-clause license that 4 * can be found in the LICENSE.txt file in the project root. 5 */ 6 7 module antlr.v4.runtime.Lexer; 8 9 import std.stdio; 10 import std.typecons; 11 import std.array; 12 import std.conv; 13 import std.variant; 14 import antlr.v4.runtime.ANTLRErrorListener; 15 import antlr.v4.runtime.Recognizer; 16 import antlr.v4.runtime.RecognitionException; 17 import antlr.v4.runtime.atn.LexerATNSimulator; 18 import antlr.v4.runtime.Token; 19 import antlr.v4.runtime.TokenConstantDefinition; 20 import antlr.v4.runtime.TokenSource; 21 import antlr.v4.runtime.InterfaceLexer; 22 import antlr.v4.runtime.TokenFactory; 23 import antlr.v4.runtime.CharStream; 24 import antlr.v4.runtime.IntStream; 25 import antlr.v4.runtime.IntStreamConstant; 26 import antlr.v4.runtime.CommonToken; 27 import antlr.v4.runtime.CommonTokenFactory; 28 import antlr.v4.runtime.IllegalStateException; 29 import antlr.v4.runtime.LexerNoViableAltException; 30 import antlr.v4.runtime.misc; 31 import antlr.v4.runtime.InterfaceRuleContext; 32 33 alias TokenFactorySourcePair = Tuple!(TokenSource, "a", CharStream, "b"); 34 35 /** 36 * A lexer is recognizer that draws input symbols from a character stream. 37 * lexer grammars result in a subclass of this object. A Lexer object 38 * uses simplified match() and error recovery mechanisms in the interest 39 * of speed. 40 */ 41 abstract class Lexer : Recognizer!(int, LexerATNSimulator), TokenSource, InterfaceLexer 42 { 43 44 public static immutable int DEFAULT_MODE = 0; 45 46 public static immutable int MORE = -2; 47 48 public static immutable int SKIP = -3; 49 50 public static immutable int DEFAULT_TOKEN_CHANNEL = TokenConstantDefinition.DEFAULT_CHANNEL; 51 52 public static immutable int HIDDEN = TokenConstantDefinition.HIDDEN_CHANNEL; 53 54 public static immutable int MIN_CHAR_VALUE = 0; 55 56 public static immutable int MAX_CHAR_VALUE = 0x10FFFF; 57 58 public CharStream _input; 59 60 protected TokenFactorySourcePair _tokenFactorySourcePair; 61 62 /** 63 * How to create token objects 64 * @uml 65 * @read 66 * @write 67 * @override 68 */ 69 public TokenFactory!CommonToken tokenFactory_; 70 71 /** 72 * The goal of all lexer rules/methods is to create a token object. 73 * This is an instance variable as multiple rules may collaborate to 74 * create a single token. nextToken will return this object after 75 * matching lexer rule(s). If you subclass to allow multiple token 76 * emissions, then set this to the last token to be matched or 77 * something nonnull so that the auto token emit mechanism will not 78 * emit another token. 79 */ 80 public Token _token; 81 82 public IntegerStack _modeStack; 83 84 /** 85 * What character index in the stream did the current token start at? 86 * Needed, for example, to get the text for current token. Set at 87 * the start of nextToken. 88 */ 89 public size_t _tokenStartCharIndex; 90 91 /** 92 * The line on which the first character of the token resides 93 */ 94 public int _tokenStartLine; 95 96 /** 97 * The character position of first character within the line 98 */ 99 public int _tokenStartCharPositionInLine; 100 101 public bool _hitEOF; 102 103 /** 104 * The channel number for the current token 105 */ 106 public int _channel; 107 108 /** 109 * The token type for the current token 110 */ 111 public int _type; 112 113 public int _mode; 114 115 /** 116 * You can set the text for the current token to override what is in 117 * the input char buffer. Use setText() or can set this instance var. 118 */ 119 public Variant _text; 120 121 public this() 122 { 123 } 124 125 public this(CharStream input) 126 { 127 tokenFactory_ = CommonTokenFactory.DEFAULT; 128 this._input = input; 129 this._tokenFactorySourcePair = tuple(this, input); 130 _modeStack = new IntegerStack(); 131 } 132 133 public void reset() 134 { 135 // wack Lexer state variables 136 if (_input !is null) { 137 _input.seek(0); // rewind the input 138 } 139 _token = null; 140 _type = TokenConstantDefinition.INVALID_TYPE; 141 _channel = TokenConstantDefinition.DEFAULT_CHANNEL; 142 _tokenStartCharIndex = -1; 143 _tokenStartCharPositionInLine = -1; 144 _tokenStartLine = -1; 145 _text.init; 146 _hitEOF = false; 147 _mode = Lexer.DEFAULT_MODE; 148 _modeStack.clear(); 149 getInterpreter().reset(); 150 } 151 152 /** 153 * Return a token from this source; i.e., match a token on the char 154 * stream. 155 */ 156 public Token nextToken() 157 { 158 if (_input is null) { 159 throw new IllegalStateException("nextToken requires a non-null input stream."); 160 } 161 // Mark start location in char stream so unbuffered streams are 162 // guaranteed at least have text of current token 163 int tokenStartMarker = _input.mark(); 164 try{ 165 outer: 166 while (true) { 167 if (_hitEOF) { 168 emitEOF(); 169 return _token; 170 } 171 _token = null; 172 _channel = TokenConstantDefinition.DEFAULT_CHANNEL; 173 _tokenStartCharIndex = _input.index; 174 _tokenStartCharPositionInLine = getInterpreter.getCharPositionInLine(); 175 _tokenStartLine = getInterpreter.getLine; 176 _text.init; 177 do { 178 _type = TokenConstantDefinition.INVALID_TYPE; 179 debug(Lexer) { 180 import std.stdio; 181 writefln("nextToken line = %s at %s: %s in mode %s at index %s", 182 _tokenStartLine, 183 _tokenStartCharPositionInLine, 184 _input.LA(1), 185 _mode, 186 _input.index); 187 } 188 int ttype; 189 try { 190 ttype = getInterpreter.match(_input, _mode); 191 } 192 catch (LexerNoViableAltException e) { 193 notifyListeners(e); // report error 194 recover(e); 195 ttype = SKIP; 196 } 197 if (_input.LA(1) == IntStreamConstant.EOF) { 198 _hitEOF = true; 199 } 200 if (_type == TokenConstantDefinition.INVALID_TYPE) _type = ttype; 201 if (_type == SKIP) { 202 continue outer; 203 } 204 } 205 while (_type == MORE); 206 207 if (_token is null) { 208 emit(); 209 } 210 return _token; 211 } 212 } 213 finally { 214 // make sure we release marker after match or 215 // unbuffered char stream will keep buffering 216 _input.release(tokenStartMarker); 217 } 218 assert(0); 219 } 220 221 /** 222 * Instruct the lexer to skip creating a token for current lexer rule 223 * and look for another token. nextToken() knows to keep looking when 224 * a lexer rule finishes with token set to SKIP_TOKEN. Recall that 225 * if token==null at end of any token rule, it creates one for you 226 * and emits it. 227 */ 228 public void skip() 229 { 230 _type = SKIP; 231 } 232 233 public void more() 234 { 235 _type = MORE; 236 } 237 238 public void mode(int m) 239 { 240 _mode = m; 241 } 242 243 public void pushMode(int m) 244 { 245 debug(LexerATNSimulator) 246 writefln("pushMode %s %s", m, _modeStack); 247 _modeStack.push(_mode); 248 mode(m); 249 } 250 251 public int popMode() 252 { 253 assert (!_modeStack.isEmpty, "Empty stack"); 254 debug(LexerATNSimulator) 255 writefln("popMode back to %s", _modeStack.peek); 256 mode(_modeStack.pop); 257 return _mode; 258 } 259 260 /** 261 * Set the char stream and reset the lexer 262 * @uml 263 * @override 264 */ 265 public override void setInputStream(IntStream input) 266 { 267 this._input = null; 268 this._tokenFactorySourcePair = tuple(this, _input); 269 reset(); 270 this._input = cast(CharStream)input; 271 this._tokenFactorySourcePair = tuple(this, _input); 272 } 273 274 public string getSourceName() 275 { 276 return _input.getSourceName(); 277 } 278 279 /** 280 * @uml 281 * @override 282 */ 283 public override CharStream getInputStream() 284 { 285 return _input; 286 } 287 288 /** 289 * By default does not support multiple emits per nextToken invocation 290 * for efficiency reasons. Subclass and override this method, nextToken, 291 * and getToken (to push tokens into a list and pull from that list 292 * rather than a single variable as this implementation does). 293 */ 294 public void emit(Token token) 295 { 296 this._token = token; 297 } 298 299 /** 300 * The standard method called to automatically emit a token at the 301 * outermost lexical rule. The token object should point into the 302 * char buffer start..stop. If there is a text override in 'text', 303 * use that to set the token's text. Override this method to emit 304 * custom Token objects or provide a new factory. 305 */ 306 public Token emit() 307 { 308 Variant v = _text; 309 Token t = tokenFactory_.create(_tokenFactorySourcePair, _type, 310 v, _channel, _tokenStartCharIndex, 311 getCharIndex()-1, _tokenStartLine, 312 _tokenStartCharPositionInLine); 313 emit(t); 314 return t; 315 } 316 317 public Token emitEOF() 318 { 319 int cpos = getCharPositionInLine(); 320 int line = getLine(); 321 Variant Null; 322 Token eof = tokenFactory_.create(_tokenFactorySourcePair, TokenConstantDefinition.EOF, Null, TokenConstantDefinition.DEFAULT_CHANNEL, 323 _input.index(), _input.index()-1, 324 line, cpos); 325 emit(eof); 326 return eof; 327 } 328 329 public int getLine() 330 { 331 return getInterpreter().getLine(); 332 } 333 334 public int getCharPositionInLine() 335 { 336 return getInterpreter().getCharPositionInLine(); 337 } 338 339 public void setLine(int line) 340 { 341 getInterpreter().setLine(line); 342 } 343 344 public void setCharPositionInLine(int charPositionInLine) 345 { 346 getInterpreter().setCharPositionInLine(charPositionInLine); 347 } 348 349 /** 350 * What is the index of the current character of lookahead? 351 */ 352 public size_t getCharIndex() 353 { 354 return _input.index(); 355 } 356 357 /** 358 * Return the text matched so far for the current token or any 359 * text override. 360 */ 361 public Variant getText() 362 { 363 Variant Null; 364 if (_text !is Null) { 365 return _text; 366 } 367 Variant v = getInterpreter().getText(_input); 368 return v; 369 } 370 371 /** 372 * Set the complete text of this token; it wipes any previous 373 * changes to the text. 374 */ 375 public void setText(Variant text) 376 { 377 this._text = text; 378 } 379 380 /** 381 * Override if emitting multiple tokens. 382 */ 383 public Token getToken() 384 { 385 return _token; 386 } 387 388 public void setToken(Token token) 389 { 390 this._token = token; 391 } 392 393 public void setType(int ttype) 394 { 395 _type = ttype; 396 } 397 398 public int getType() 399 { 400 return _type; 401 } 402 403 public void setChannel(int channel) 404 { 405 _channel = channel; 406 } 407 408 public int getChannel() 409 { 410 return _channel; 411 } 412 413 public string[] getChannelNames() 414 { 415 return null; 416 } 417 418 public string[] getModeNames() 419 { 420 return null; 421 } 422 423 /** 424 * Used to print out token names like ID during debugging and 425 * error reporting. The generated parsers implement a method 426 * that overrides this to point to their String[] tokenNames 427 * @uml 428 * @override 429 */ 430 public override string[] getTokenNames() 431 { 432 return null; 433 } 434 435 /** 436 * Return a list of all Token objects in input char stream. 437 * Forces load of all tokens. Does not include EOF token. 438 */ 439 public Token[] getAllTokens() 440 { 441 Token[] tokens; 442 Token t = nextToken(); 443 while (t.getType() != TokenConstantDefinition.EOF) { 444 tokens ~= t; 445 t = nextToken(); 446 } 447 return tokens; 448 } 449 450 public void recover(LexerNoViableAltException e) 451 { 452 if (_input.LA(1) != IntStreamConstant.EOF) { 453 // skip a char and try again 454 getInterpreter().consume(_input); 455 } 456 } 457 458 public void notifyListeners(LexerNoViableAltException e) 459 { 460 auto text = _input.getText(Interval.of(to!int(_tokenStartCharIndex), to!int(_input.index))); 461 auto msg = "token recognition error at: '" ~ getErrorDisplay(text) ~ "'"; 462 ANTLRErrorListener!(int, LexerATNSimulator) listener = getErrorListenerDispatch(); 463 listener.syntaxError(this, null, _tokenStartLine, _tokenStartCharPositionInLine, msg, e); 464 } 465 466 public string getErrorDisplay(string s) 467 { 468 auto buf = appender!string; 469 foreach (dchar c; s) { 470 buf.put(getErrorDisplay(c)); 471 } 472 return buf.data; 473 } 474 475 public string getErrorDisplay(dchar c) 476 { 477 string s; 478 switch ( c ) { 479 case TokenConstantDefinition.EOF : 480 s = "<EOF>"; 481 break; 482 case '\n' : 483 s = "\\n"; 484 break; 485 case '\t' : 486 s = "\\t"; 487 break; 488 case '\r' : 489 s = "\\r"; 490 break; 491 default: 492 s ~= c; 493 break; 494 } 495 return s; 496 } 497 498 public string getCharErrorDisplay(dchar c) 499 { 500 string s = getErrorDisplay(c); 501 return "'" ~ s ~ "'"; 502 } 503 504 /** 505 * Lexers can normally match any char in it's vocabulary after matching 506 * a token, so do the easy thing and just kill a character and hope 507 * it all works out. You can instead use the rule invocation stack 508 * to do sophisticated error recovery if you are in a fragment rule. 509 */ 510 public void recover(RecognitionException re) 511 { 512 //System.out.println("consuming char "+(char)input.LA(1)+" during recovery"); 513 //re.printStackTrace(); 514 // TODO: Do we lose character or line position information? 515 _input.consume(); 516 } 517 518 /** 519 * @uml 520 * @override 521 */ 522 public override void action(InterfaceRuleContext interfaceRuleContext, int ruleIndex, 523 int actionIndex) 524 { 525 } 526 527 public override final TokenFactory!CommonToken tokenFactory() 528 { 529 return this.tokenFactory_; 530 } 531 532 public override final void tokenFactory(TokenFactory!CommonToken tokenFactory) 533 { 534 this.tokenFactory_ = tokenFactory; 535 } 536 537 }