A.3 词法分析器

包 lexer 是词法分析器的代码的扩展。类 Tag 定义了各个词法单元对应的常量。

package lexer;
public class Tag {
    public final static int
        AND = 256 , BASIC = 257 , BREAK = 258 , DO = 259 , ELSE = 260 ,
        EQ = 261 , FALSE = 262 , GE = 263 , ID = 264 , IF = 265 ,
        INDEX = 266 , LE = 267 , MINUS = 268 , NE = 269 , NUM = 270 ,
        OR = 271 , REAL = 272 , TEMP = 273 , TRUE = 274 , WHILE = 275 ;
}

其中的三个常量 INDEX、MINUS、和TEMP不是词法单元他们将在抽象语法树中使用。

类Token和Num增加了方法toString;

 

package lexer;
public class Token {
    public final static int tag;

    public Token(int t){
        tag=t;
    }

    public String toString(){
        return ""+(char)tag;
    }
}

package lexer;                             //文件 Num.java
public class Num extends Token{
    public final value;

    public Num(int v){
        super(Tag.NUM);
        value=v;
    }

    public String toString(){
        return "" + value;
    }
}

类Word用于管理保留字、标识符和像 && 这样的复合词法单元的词素。它也可以用来管理在中间代码中运算符的书写符号形式；比如单目减号。例如，原文件中的 –2 的中间形式是minus 2.

package lexer;
public class Word extends Token{
    public String lexeme = "";

    public Word(String s ,int tag){
        super(tag);
        lexeme = s;
    }

    public String toString(){
        return lexeme;
    }

    public static final Word
        and = new Word("&&",Tag.AND), or = new Word("||",Tag.OR),
        eq = new Word("==",Tag.EQ), ne = new Word("!=",Tag.NE),
        le = new Word("<=",Tag.LE), ge = new Word(">=",Tag.GE),
        minus = new Word("minus",Tag.MINUS),
        True = new Word("true",Tag.TRUE),
        False = new Word("false",Tag.FAlSE),
        temp = new Word("t",Tag.TEMP);
}

类Real用于处理浮点数：

package lexer;
public class Real extends Token{
    public final float value;

    public Real(float v){
        super(Tag.REAL);
        value = v;
    }

    public String toString(){
        return "" + value;
    }
}

类Lexer的主方法，即函数scan，识别数字、标识符和保留字。

类Lexer中的第9~13行保留了关键字。第14~16行保留了在其他地方定义的对象的词素。对象Word.True和Word.False在类Word中定义。对应于基本类型 int 、char、bool 和 float 的对象在类 Type 中定义。类Type 是Word 的一个子类。类 Type 来自包 symbols .

package lexer;                     //文件Lexer.java
import java.io.*;
import java.util.*;
import symbols.*;
public class Lexer{
    public static int line = 1;
    char peek = ' ';
    Hashtable words = new Hashtalbe();

    void reverse(Word w){
        words.put(w.lexeme,w);
    }

    public Lexer(){
        reverse(new Word("if",Tag.IF));
        reverse(new Word("else",Tag.ELSE));
        reverse(new Word("while",Tag.WHILE));
        reverse(new Word("do",Tag.DO));
        reverse(new Word("break",Tag.BREAK));
        reverse(Word.True);
        reverse(Word.False);
        reverse(Word.Int);
        reverse(Word.Char);
        reverse(Word.Bool);
        reverse(Word.Float);
}

函数readch()(第18行)用于把下一个输入字符读到变量peek中。名字readch被复用或重载，（第19~24行），以便帮助识别复合的词法单元。比如，一看到输入字符<，调用readch(“=”)就会把下一个字符读入peek，并检查它是否为=。

void readch() throws IOException{
    peek=(char) System.in.read();
}

boolean readch(char c)throws IOException{
    readch();
    if(peek != c)
        return false;
    peek = ' ';
    return true;
}

函数scan一开始首先略过所有的空白字符（第26~30行）。它首先试图识别像<=这样的复合词法单元（第31~34行）和项365这样的数字（第45~58行）。如果不成功，他就试图读入一个字符串（第59~70行）。

public Token scan() throws IOException{
    for( ; ; readch()){
        if(peek == ' '|| peek == '	')
            continue;
        else if(peek == '
')
            line=line+1;
        else
            break;

        switch(peek){
            case '&':
                if(readch('&'))
                    return Word.and;
                else
                    return new Token('&');
            case '|':
                if(readch('|'))
                    return Word.or;
                else
                    return new Token('|');
            case '=':
                if(readch('='))
                    return Word.eq;
                else
                    return new Token('=');
            case '!':
                if(readch('!'))
                    return Word.ne;
                else
                    return new Token('!');
            case '<':
                if(readch('<'))
                    return Word.le;
                else
                    return new Token('<');
            case '>':
                if(readch('>'))
                    return Word.ge;
                else
                    return new Token('>');
        }

        if(Character.isDigit(peek)){
            int v=0;
            do{
                v=10*v=Character.digit(peek,10);
                readch();
            }while(Character.isDigit(peek));

            if(peek!='.')
                return new Num(v);
            float x= v;
            float d=10;
            for( ; ; ){
                readch();
                if(! Character.isDigit(peek))
                    break;
                x=x+Character.digit(peek,10)/d;
                d=d*10;
            }
            return new Real(x);
        }

        if(Character.isLetter(peek)){
            StringBuffer b=new StringBuffer();
            do{
                b.append(peek);
                readch();
            }while(Character.isLetterOrDigit(peek));
            String s=b.toString();
            Word w=(Word)words.get(s);
            if(w!=null)
                return w;
            w = new Word(s,Tag.ID);
            words.put(s,w);
            return w;
        }
        Token tok=new Token(peek);
        peek=' ';
        return tok;
    }
}

最后，peek中的任意字符都被作为词法单元返回。