分析源代码中的每个类的成员函数及其作用，分析源代码中的不同类的调用关系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 ); }

and", Tag.AND ),
or = new Word( "or", 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 );

Word类继承自Token类，并且有一个成员变量lexeme，表示单词的字符串值。构造函数接受一个字符串和一个标签值，用于初始化lexeme和tag成员变量。toString()函数返回lexeme成员变量的值。此外，类中还定义了一些静态的Word对象，表示不同的关键字和符号。

package lexer;
public class Token {
public final int tag;
public Token(int t) { tag = t; }
public String toString() { return "" + (char)tag; }

Token类有一个成员变量tag，表示标签值。构造函数接受一个标签值，用于初始化tag成员变量。toString()函数返回tag成员变量的ASCII字符值。

package lexer;
import java.io.*;
import java.util.*;
public class Lexer {
public static int line = 1;
private char peek = ' ';
private Hashtable words = new Hashtable();
void reserve(Word w) { words.put(w.lexeme, w); }
public Lexer() {
reserve( new Word("if", Tag.IF) );
reserve( new Word("else", Tag.ELSE) );
reserve( new Word("while", Tag.WHILE) );
reserve( new Word("do", Tag.DO) );
reserve( new Word("break", Tag.BREAK) );
reserve( True ); reserve( False );
reserve( Type.Int ); reserve( Type.Char );
reserve( Type.Bool ); reserve( Type.Float );
}
public Token scan() throws IOException {
for( ; ; peek = (char)System.in.read() ) {
if( peek == ' ' || peek == '\t' ) continue;
else if( peek == '\n' ) line = line + 1;
else break;
}
if( Character.isDigit(peek) ) {
int v = 0;
do {
v = 10*v + Character.digit(peek, 10); peek = (char)System.in.read();
} while( Character.isDigit(peek) );
if( peek != '.' ) return new Num(v);
float x = v; float d = 10;
for(;;) {
peek = (char)System.in.read();
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); peek = (char)System.in.read();
} 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;
}
}

Lexer类用于实现词法分析器，它通过从标准输入中读取字符，逐个识别输入的单词，并返回对应的Token对象。它有一个静态的line成员变量表示当前行数，一个peek成员变量表示当前读取到的字符，一个words成员变量表示保留字表。reserve()函数用于向保留字表中添加保留字。构造函数中调用reserve()函数添加了一些保留字和类型关键字。scan()函数用于识别输入的单词，并返回对应的Token对象。它首先通过循环跳过空格和制表符，并记录当前行数；然后判断下一个字符是数字还是字母，分别进行处理，最后返回对应的Token对象。

package lexer;
public class Type extends Word {
public int width = 0;
public Type(String s, int tag, int w) { super(s, tag); width = w; }
public static final Type
Int = new Type("int", Tag.BASIC, 4),
Float = new Type("float", Tag.BASIC, 8),
Char = new Type("char", Tag.BASIC, 1),
Bool = new Type("bool", Tag.BASIC, 1);
public static boolean numeric(Type p) {
if (p == Type.Char || p == Type.Int || p == Type.Float) return true;
else return false;
}
public static Type max(Type p1, Type p2) {
if ( ! numeric(p1) || ! numeric(p2) ) return null;
else if (p1 == Type.Float || p2 == Type.Float) return Type.Float;
else if (p1 == Type.Int || p2 == Type.Int ) return Type.Int;
else return Type.Char;
}
}

Type类继承自Word类，表示类型关键字。它有一个成员变量width，表示类型的字节数。构造函数接受一个字符串、一个标签值和一个字节数，用于初始化lexeme、tag和width成员变量。此外，类中还定义了一些静态的Type对象，表示不同的类型关键字。类中有一个numeric()函数，用于判断一个类型是否是数字类型。还有一个max()函数，用于计算两个类型中较大的类型。