Robust/src/Lex/Lexer.java

   1 package Lex;
   2
   3 import java.io.IOException;
   4 import java.io.Reader;
   5 import java.io.LineNumberReader;
   6 import Parse.Sym;
   7
   8 /* Java lexer.
   9  * Copyright (C) 2002 C. Scott Ananian <cananian@alumni.princeton.edu>
  10  * This program is released under the terms of the GPL; see the file
  11  * COPYING for more details.  There is NO WARRANTY on this code.
  12  */
  13
  14 public class Lexer {
  15   LineNumberReader reader;
  16   boolean isJava12;
  17   boolean isJava14;
  18   boolean isJava15;
  19   String line = null;
  20   int line_pos = 1;
  21     public int line_num = 0;
  22   LineList lineL = new LineList(-line_pos, null); // sentinel for line #0
  23
  24   public Lexer(Reader reader) {
  25     this.reader = new LineNumberReader(new EscapedUnicodeReader(reader));
  26     this.isJava12 = true;
  27     this.isJava14 = true;
  28   }
  29
  30   public java_cup.runtime.Symbol nextToken() throws java.io.IOException {
  31     java_cup.runtime.Symbol sym =
  32       lookahead==null ? _nextToken() : lookahead.get();
  33     last = sym;
  34     return sym;
  35   }
  36   private boolean shouldBePLT() throws java.io.IOException {
  37     // look ahead to see if this LT should be changed to a PLT
  38     if (last==null || last.sym!=Sym.IDENTIFIER)
  39       return false;
  40     if (lookahead==null) lookahead = new FIFO(new FIFO.Getter() {
  41                                                 java_cup.runtime.Symbol next() throws java.io.IOException
  42                                                 { return _nextToken(); }
  43                                               });
  44     int i=0;
  45     // skip past IDENTIFIER (DOT IDENTIFIER)*
  46     if (lookahead.peek(i++).sym != Sym.IDENTIFIER)
  47       return false;
  48     while (lookahead.peek(i).sym == Sym.DOT) {
  49       i++;
  50       if (lookahead.peek(i++).sym != Sym.IDENTIFIER)
  51         return false;
  52     }
  53     // skip past (LBRACK RBRACK)*
  54     while (lookahead.peek(i).sym == Sym.LBRACK) {
  55       i++;
  56       if (lookahead.peek(i++).sym != Sym.RBRACK)
  57         return false;
  58     }
  59     // now the next sym has to be one of LT GT COMMA EXTENDS IMPLEMENTS
  60     switch(lookahead.peek(i).sym) {
  61     default:
  62       return false;
  63
  64     case Sym.LT:
  65     case Sym.GT:
  66     case Sym.COMMA:
  67     case Sym.EXTENDS:
  68       return true;
  69     }
  70   }
  71   private java_cup.runtime.Symbol last = null;
  72   private FIFO lookahead = null;
  73   public java_cup.runtime.Symbol _nextToken() throws java.io.IOException {
  74     /* tokens are:
  75      *  Identifiers/Keywords/true/false/null (start with java letter)
  76      *  numeric literal (start with number)
  77      *  character literal (start with single quote)
  78      *  string (start with double quote)
  79      *  separator (parens, braces, brackets, semicolon, comma, period)
  80      *  operator (equals, plus, minus, etc)
  81      *  whitespace
  82      *  comment (start with slash)
  83      */
  84     InputElement ie;
  85     int startpos, endpos;
  86     do {
  87       startpos = lineL.head + line_pos;
  88       ie = getInputElement();
  89       if (ie instanceof DocumentationComment)
  90         comment = ((Comment)ie).getComment();
  91     } while (!(ie instanceof Token));
  92     endpos = lineL.head + line_pos - 1;
  93
  94     // System.out.println(ie.toString()); // uncomment to debug lexer.
  95     java_cup.runtime.Symbol sym = ((Token)ie).token();
  96     // fix up left/right positions.
  97     sym.left = startpos; sym.right = endpos;
  98     // return token.
  99     return sym;
 100   }
 101   public boolean debug_lex() throws java.io.IOException {
 102     InputElement ie = getInputElement();
 103     System.out.println(ie);
 104     return !(ie instanceof EOF);
 105   }
 106
 107   String comment;
 108   public String lastComment() {
 109     return comment;
 110   }
 111   public void clearComment() {
 112     comment="";
 113   }
 114
 115   InputElement getInputElement() throws java.io.IOException {
 116     if (line_num == 0)
 117       nextLine();
 118     if (line==null)
 119       return new EOF();
 120     if (line.length()<=line_pos) {      // end of line.
 121       nextLine();
 122       if (line==null)
 123         return new EOF();
 124     }
 125
 126     switch (line.charAt(line_pos)) {
 127
 128       // White space:
 129     case ' ':    // ASCII SP
 130     case '\t':    // ASCII HT
 131     case '\f':    // ASCII FF
 132     case '\n':    // LineTerminator
 133       return new WhiteSpace(consume());
 134
 135       // EOF character:
 136     case '\020': // ASCII SUB
 137       consume();
 138       return new EOF();
 139
 140       // Comment prefix:
 141     case '/':
 142       return getComment();
 143
 144       // else, a Token
 145     default:
 146       return getToken();
 147     }
 148   }
 149   // May get Token instead of Comment.
 150   InputElement getComment() throws java.io.IOException {
 151     String comment;
 152     // line.charAt(line_pos+0) is '/'
 153     switch (line.charAt(line_pos+1)) {
 154     case '/': // EndOfLineComment
 155       comment = line.substring(line_pos+2);
 156       line_pos = line.length();
 157       return new EndOfLineComment(comment);
 158
 159     case '*': // TraditionalComment or DocumentationComment
 160       line_pos += 2;
 161       if (line.charAt(line_pos)=='*') { // DocumentationComment
 162         return snarfComment(new DocumentationComment());
 163       } else { // TraditionalComment
 164         return snarfComment(new TraditionalComment());
 165       }
 166
 167     default: // it's a token, not a comment.
 168       return getToken();
 169     }
 170   }
 171
 172   Comment snarfComment(Comment c) throws java.io.IOException {
 173     StringBuffer text=new StringBuffer();
 174     while(true) { // Grab CommentTail
 175       while (line.charAt(line_pos)!='*') { // Add NotStar to comment.
 176         int star_pos = line.indexOf('*', line_pos);
 177         if (star_pos<0) {
 178           text.append(line.substring(line_pos));
 179           c.appendLine(text.toString()); text.setLength(0);
 180           line_pos = line.length();
 181           nextLine();
 182           if (line==null)
 183             throw new IOException("Unterminated comment at end of file.");
 184         } else {
 185           text.append(line.substring(line_pos, star_pos));
 186           line_pos=star_pos;
 187         }
 188       }
 189       // At this point, line.charAt(line_pos)=='*'
 190       // Grab CommentTailStar starting at line_pos+1.
 191       if (line.charAt(line_pos+1)=='/') { // safe because line ends with '\n'
 192         c.appendLine(text.toString()); line_pos+=2; return c;
 193       }
 194       text.append(line.charAt(line_pos++)); // add the '*'
 195     }
 196   }
 197
 198   Token getToken() throws java.io.IOException {
 199     // Tokens are: Identifiers, Keywords, Literals, Separators, Operators.
 200     switch (line.charAt(line_pos)) {
 201       // Separators: (period is a special case)
 202     case '(':
 203     case ')':
 204     case '{':
 205     case '}':
 206     case '[':
 207     case ']':
 208     case ';':
 209     case ',':
 210       return new Separator(consume());
 211
 212       // Operators:
 213     case '=':
 214     case '>':
 215     case '<':
 216     case '!':
 217     case '~':
 218     case '?':
 219     case ':':
 220     case '&':
 221     case '|':
 222     case '+':
 223     case '-':
 224     case '*':
 225     case '/':
 226     case '^':
 227     case '%':
 228       return getOperator();
 229
 230     case '\'':
 231       return getCharLiteral();
 232
 233     case '\"':
 234       return getStringLiteral();
 235
 236       // a period is a special case:
 237     case '.':
 238       if (Character.digit(line.charAt(line_pos+1),10)!=-1)
 239         return getNumericLiteral();
 240       else if (isJava15 &&
 241                line.charAt(line_pos+1)=='.' &&
 242                line.charAt(line_pos+2)=='.') {
 243         consume(); consume(); consume();
 244         return new Separator('\u2026'); // unicode ellipsis character.
 245       } else return new Separator(consume());
 246
 247     default:
 248       break;
 249     }
 250     if (Character.isJavaIdentifierStart(line.charAt(line_pos)))
 251       return getIdentifier();
 252     if (Character.isDigit(line.charAt(line_pos)))
 253       return getNumericLiteral();
 254     throw new IOException("Illegal character on line "+line_num);
 255   }
 256
 257   static final String[] keywords = new String[] {
 258     "abstract", "assert", "atomic", "boolean", "break", "byte", "case", "catch", "char",
 259     "class", "const", "continue",
 260     "default", "disjoint", "do", "double",
 261     "else", "enum",
 262     "extends", "external", "final", "finally",
 263     "flag", //keyword for failure aware computation
 264     "float", "for","getoffset", "global", "goto", "if",
 265     //"implements",
 266     "import", "instanceof", "int",
 267     //"interface",
 268     "isavailable",
 269     "long",
 270     "native", "new", "optional", "package", "private", "protected", "public",
 271     "rblock", "return",
 272     "scratch", "sese", "short", "static", "strictfp", "super", "switch", "synchronized",
 273     "tag", "task", "taskexit", //keywords for failure aware computation
 274     "this", "throw", "throws", "transient", "try", "void",
 275     "volatile", "while"
 276   };
 277   Token getIdentifier() throws java.io.IOException {
 278     // Get id string.
 279     StringBuffer sb = new StringBuffer().append(consume());
 280
 281     if (!Character.isJavaIdentifierStart(sb.charAt(0)))
 282       throw new IOException("Invalid Java Identifier on line "+line_num);
 283     while (Character.isJavaIdentifierPart(line.charAt(line_pos)))
 284       sb.append(consume());
 285     String s = sb.toString();
 286     // Now check against boolean literals and null literal.
 287     if (s.equals("null")) return new NullLiteral();
 288     if (s.equals("true")) return new BooleanLiteral(true);
 289     if (s.equals("false")) return new BooleanLiteral(false);
 290     // Check against keywords.
 291     //  pre-java 1.5 compatibility:
 292     if (!isJava15 && s.equals("enum")) return new Identifier(s);
 293     //  pre-java 1.4 compatibility:
 294     if (!isJava14 && s.equals("assert")) return new Identifier(s);
 295     //  pre-java 1.2 compatibility:
 296     if (!isJava12 && s.equals("strictfp")) return new Identifier(s);
 297     // use binary search.
 298     for (int l=0, r=keywords.length; r > l; ) {
 299       int x = (l+r)/2, cmp = s.compareTo(keywords[x]);
 300       if (cmp < 0) r=x;else l=x+1;
 301       if (cmp== 0) return new Keyword(s);
 302     }
 303     // not a keyword.
 304     return new Identifier(s);
 305   }
 306   NumericLiteral getNumericLiteral() throws java.io.IOException {
 307     int i;
 308     // leading decimal indicates float.
 309     if (line.charAt(line_pos)=='.')
 310       return getFloatingPointLiteral();
 311     // 0x indicates Hex.
 312     if (line.charAt(line_pos)=='0' &&
 313         (line.charAt(line_pos+1)=='x' ||
 314          line.charAt(line_pos+1)=='X')) {
 315       line_pos+=2; return getIntegerLiteral(/*base*/ 16);
 316     }
 317     // otherwise scan to first non-numeric
 318     for (i=line_pos; Character.digit(line.charAt(i),10)!=-1; )
 319       i++;
 320     switch(line.charAt(i)) { // discriminate based on first non-numeric
 321     case '.':
 322     case 'f':
 323     case 'F':
 324     case 'd':
 325     case 'D':
 326     case 'e':
 327     case 'E':
 328       return getFloatingPointLiteral();
 329
 330     case 'L':
 331     case 'l':
 332     default:
 333       if (line.charAt(line_pos)=='0')
 334         return getIntegerLiteral(/*base*/ 8);
 335       return getIntegerLiteral(/*base*/ 10);
 336     }
 337   }
 338   NumericLiteral getIntegerLiteral(int radix) throws java.io.IOException {
 339     long val=0;
 340     while (Character.digit(line.charAt(line_pos),radix)!=-1)
 341       val = (val*radix) + Character.digit(consume(),radix);
 342     if (line.charAt(line_pos) == 'l' ||
 343         line.charAt(line_pos) == 'L') {
 344       consume();
 345       return new LongLiteral(val);
 346     }
 347     // we compare MAX_VALUE against val/2 to allow constants like
 348     // 0xFFFF0000 to get past the test. (unsigned long->signed int)
 349     if ((val/2) > Integer.MAX_VALUE ||
 350         val    < Integer.MIN_VALUE)
 351       throw new IOException("Constant does not fit in integer on line "+line_num);
 352     return new IntegerLiteral((int)val);
 353   }
 354   NumericLiteral getFloatingPointLiteral() throws java.io.IOException {
 355     String rep = getDigits();
 356     if (line.charAt(line_pos)=='.')
 357       rep+=consume() + getDigits();
 358     if (line.charAt(line_pos)=='e' ||
 359         line.charAt(line_pos)=='E') {
 360       rep+=consume();
 361       if (line.charAt(line_pos)=='+' ||
 362           line.charAt(line_pos)=='-')
 363         rep+=consume();
 364       rep+=getDigits();
 365     }
 366     try {
 367       switch (line.charAt(line_pos)) {
 368       case 'f':
 369       case 'F':
 370         consume();
 371         return new FloatLiteral(Float.valueOf(rep).floatValue());
 372
 373       case 'd':
 374       case 'D':
 375         consume();
 376
 377         /* falls through */
 378       default:
 379         return new DoubleLiteral(Double.valueOf(rep).doubleValue());
 380       }
 381     } catch (NumberFormatException e) {
 382       throw new IOException("Illegal floating-point on line "+line_num+": "+e);
 383     }
 384   }
 385   String getDigits() {
 386     StringBuffer sb = new StringBuffer();
 387     while (Character.digit(line.charAt(line_pos),10)!=-1)
 388       sb.append(consume());
 389     return sb.toString();
 390   }
 391
 392   Operator getOperator() {
 393     char first = consume();
 394     char second= line.charAt(line_pos);
 395
 396     switch(first) {
 397       // single-character operators.
 398     case '~':
 399     case '?':
 400     case ':':
 401       return new Operator(new String(new char[] {first}));
 402
 403       // doubled operators
 404     case '+':
 405     case '-':
 406     case '&':
 407     case '|':
 408       if (first==second)
 409         return new Operator(new String(new char[] {first, consume()}));
 410
 411     default:
 412       break;
 413     }
 414     // Check for trailing '='
 415     if (second=='=')
 416       return new Operator(new String(new char[] {first, consume()}));
 417
 418     // Special-case '<<', '>>' and '>>>'
 419     if ((first=='<' && second=='<') || // <<
 420         (first=='>' && second=='>')) {  // >>
 421       String op = new String(new char[] {first, consume()});
 422       if (first=='>' && line.charAt(line_pos)=='>') // >>>
 423         op += consume();
 424       if (line.charAt(line_pos)=='=') // <<=, >>=, >>>=
 425         op += consume();
 426       return new Operator(op);
 427     }
 428
 429     // Otherwise return single operator.
 430     return new Operator(new String(new char[] {first}));
 431   }
 432
 433   CharacterLiteral getCharLiteral() throws java.io.IOException {
 434     char firstquote = consume();
 435     char val;
 436     switch (line.charAt(line_pos)) {
 437     case '\\':
 438       val = getEscapeSequence();
 439       break;
 440
 441     case '\'':
 442       throw new IOException("Invalid character literal on line "+line_num);
 443
 444     case '\n':
 445       throw new IOException("Invalid character literal on line "+line_num);
 446
 447     default:
 448       val = consume();
 449       break;
 450     }
 451     char secondquote = consume();
 452     if (firstquote != '\'' || secondquote != '\'')
 453       throw new IOException("Invalid character literal on line "+line_num);
 454     return new CharacterLiteral(val);
 455   }
 456   StringLiteral getStringLiteral() throws java.io.IOException {
 457     char openquote = consume();
 458     StringBuffer val = new StringBuffer();
 459     while (line.charAt(line_pos)!='\"') {
 460       switch(line.charAt(line_pos)) {
 461       case '\\':
 462         val.append(getEscapeSequence());
 463         break;
 464
 465       case '\n':
 466         throw new IOException("Invalid string literal on line " + line_num);
 467
 468       default:
 469         val.append(consume());
 470         break;
 471       }
 472     }
 473     char closequote = consume();
 474     if (openquote != '\"' || closequote != '\"')
 475       throw new IOException("Invalid string literal on line " + line_num);
 476
 477     return new StringLiteral(val.toString().intern());
 478   }
 479
 480   char getEscapeSequence() throws java.io.IOException {
 481     if (consume() != '\\')
 482       throw new IOException("Invalid escape sequence on line " + line_num);
 483     switch(line.charAt(line_pos)) {
 484     case 'b':
 485       consume(); return '\b';
 486
 487     case 't':
 488       consume(); return '\t';
 489
 490     case 'n':
 491       consume(); return '\n';
 492
 493     case 'f':
 494       consume(); return '\f';
 495
 496     case 'r':
 497       consume(); return '\r';
 498
 499     case '\"':
 500       consume(); return '\"';
 501
 502     case '\'':
 503       consume(); return '\'';
 504
 505     case '\\':
 506       consume(); return '\\';
 507
 508     case '0':
 509     case '1':
 510     case '2':
 511     case '3':
 512       return (char) getOctal(3);
 513
 514     case '4':
 515     case '5':
 516     case '6':
 517     case '7':
 518       return (char) getOctal(2);
 519
 520     default:
 521       throw new IOException("Invalid escape sequence on line " + line_num);
 522     }
 523   }
 524   int getOctal(int maxlength) throws java.io.IOException {
 525     int i, val=0;
 526     for (i=0; i<maxlength; i++)
 527       if (Character.digit(line.charAt(line_pos), 8)!=-1) {
 528         val = (8*val) + Character.digit(consume(), 8);
 529       } else break;
 530     if ((i==0) || (val>0xFF)) // impossible.
 531       throw new IOException("Invalid octal escape sequence in line " + line_num);
 532     return val;
 533   }
 534
 535   char consume() {
 536     return line.charAt(line_pos++);
 537   }
 538   void nextLine() throws java.io.IOException {
 539     line=reader.readLine();
 540     if (line!=null) line=line+'\n';
 541     lineL = new LineList(lineL.head+line_pos, lineL); // for error reporting
 542     line_pos=0;
 543     line_num++;
 544   }
 545
 546   // Deal with error messages.
 547   public void errorMsg(String msg, java_cup.runtime.Symbol info) {
 548     int n=line_num, c=info.left-lineL.head;
 549     for (LineList p = lineL; p!=null; p=p.tail, n--)
 550       if (p.head<=info.left) {
 551         c=info.left-p.head; break;
 552       }
 553     System.err.println(msg+" at line "+n);
 554     num_errors++;
 555   }
 556   private int num_errors = 0;
 557   public int numErrors() {
 558     return num_errors;
 559   }
 560
 561   class LineList {
 562     int head;
 563     LineList tail;
 564     LineList(int head, LineList tail) {
 565       this.head = head; this.tail = tail;
 566     }
 567   }
 568 }