7/3
1.1.1 1.1.2 编译器将源程序编译成目标程序,执行时,不再需要编译,效率很高,但在不同的平台需要重新编译成可执行文件。解释器一边运行一边解释源代码,可以实现跨平台的编码,但其效率低于编译器。由于解释器逐条执行语句,其检查错误的能力强于编译器。
1.1.3 汇编语言更容易输出和调试,编译器产生汇编语言可以让编译器的设计本身更专注,将其他的工作交给汇编器。
1.1.4 c语言牛逼呀。。。简单易理解,方便输出调试。
1.1.5 汇编器类似于编译器,将汇编程序作为源程序,输出机器代码。
1.3.1 略
1.6.1 w=13 x=11 y=13 z=11
1.6.2 w=9 x=7 y=13 z=11
1.6.3 int w B1-B3-B4
int x B1-B2-B4
int y B1-B5
int z B1-B2-B5
int x B2-B3
int z B2
int w B3
int x B3
int w B4
int x B4
int y B5
int z B5
1.6.4 3 2
2.2.1 t->aa+
s->ta*
r->s
s
t a *
a a +
+*后缀表达式
2.2.2 1) 0n1n n>=1
2) +-前缀表达式
3) 一堆匹配括号
4) 由成对a,b组成的串或空串
5) 以a为元素,具有合并 连接 闭包 括号运算
2.2.3 3 4 5
2.2.4
1)expr->expr term + | expr term - | term
term->term factor * | term factor / | factor
factor->digit | (expr)
2)stmt->stmt , id | id
3)stmt-> id , stmt | id
4)expr -> expr + term | expr - term | term
term -> term * factor | term / factor | factor
factor->id | digit | (expr)
5)expr -> expr + term | expr - term | term
term -> term * factor | term / factor | signedfactor
signedfactor-> + factor | - factor
factor -> id | digit | (expr)
2.2.5 11 十进制是 3
1001 十进制是 9
num 0 ,如果num被3整除,这个操作相当于十进制乘2,自然也被3整除
num num ,如果num被3整除,这个操作相当于十进制num*(2^digit(num)+1),digit()是num的二进制长度,自然也被3整除
假设有这么一个二进制数它能被3整除并不能由这个串生成:考虑
1)以0结尾,那么num 0将是生成这个串的一个方法,只需要向下考虑num是否能被表示,故0结尾的问题不用分析
2)以1结尾,经过对余数的分析发现,并不能表示所有的被三整除数,如 10101 (21)就无法生成
2.2.6 不懂罗马数字。。。。
2.3.1 expr->'-' || expr1 || term | '+' || expr2 || term | term
term->'*' || term1 || factor | '/' || term2 || factor | factor
factor->digit | (expr)
9-5+2 +-952
9-5*2 -9*52
2.3.2 expr-> expr1 || '-' || term | expr2 || '+' || term | term
term-> term1 || '*' || factor | term2 || '/' || factor | factor
factor->digit | (expr)
2.3.3 对罗马数字一窍不通
2.3.4 同上
2.3.5 expr-> {print('-')} expr1 term - | {print('+')} expr2 term + | term
term->{print('*')} term1 factor * | {print('/')} term2 factor / | factor
factor->{print(digit)} digit | (expr)
2.4.1
1) stmt-> '+' || stmt1 || stmt2 | '-' || stmt3 || stmt4 | a
void stmt(){
switch(lookahead){
case '+': match('+');stmt();stmt();break;
case '-': match('-');stmt();stmt();break;
case 'a': match('a');break;
default: report('syntax error');
}
}
match(terminal t){
if(lookahead==t) lookahead=nextTerminal;
else report('syntax error');
}
2) stmt -> stmt1 || '(' || stmt2 || ')' || stmt3 | ε
void stmt(){
switch(lookahead){
case '(': match('(');stmt();match(')');break;
case ')':break;
default: report('syntax error');
}
}
match(terminal t){
if(lookahead==t) lookahead=nextTerminal;
else report('syntax error');
}
3)stmt ->'0' || stmt1 || '1' | '01'
void stmt(){
switch(lookahead){
case '0': match('0');stmt();match('1');break;
case '1':break;
default: report('syntax error');
}
}
match(terminal t){
if(lookahead==t) lookahead=nextTerminal;
else report('syntax error');
}
2.6
package afterExpression;
import java.io.IOException;
import java.util.Hashtable;
public class Lexer {
private int peek = ' ';
private int line = 1;
private Hashtable<String, Word> reverseWord = new Hashtable<>();
public Lexer() {
reserve(new Word(Tag.TRUE, "true"));
reserve(new Word(Tag.FALSE, "false"));
}
private void reserve(Word word) {
reverseWord.put(word.getExpression(), word);
}
public Token scan() throws IOException {
// 跳过空白符,换行符,记录行号
for (;; peek = System.in.read()) {
if (peek == ' ' || peek == '\t') {
continue;
} else if (peek == '\n') {
line += 1;
continue;
} else {
break;
}
}
// 处理注释
if (peek == '/') {
peek = System.in.read();
if (peek == '/') {
// 行级注释
while (peek != '\n') {
peek = System.in.read();
}
peek = ' ';
return scan();
}
if (peek == '*') {
// 层级注释
while (true) {
peek = System.in.read();
if (peek == '*') {
peek = System.in.read();
if (peek == '/') {
peek = ' ';
return scan();
}
}
}
}
return new Token('/');
}
// 处理<= < == != >= >
if (peek == '<' || peek == '=' || peek == '!' || peek == '>') {
StringBuffer sb = new StringBuffer();
sb.append((char) peek);
peek = System.in.read();
if (peek != '=') {
return new Operator(Tag.RELATION, sb.toString());
} else {
peek = ' ';
sb.append('=');
return new Operator(Tag.RELATION, sb.toString());
}
}
// 处理数字
if (Character.isDigit(peek)) {
int num = 0;
// 向后读每次*10+新读数
do {
num = 10 * num + Character.digit(peek, 10);
peek = System.in.read();
} while (Character.isDigit(peek));
if (peek == '.') {
double floatnum = num;
peek = System.in.read();
int digitNum = 1;
while (Character.isDigit(peek)) {
floatnum = floatnum + Character.digit(peek, 10)
* Math.pow(0.1, digitNum);
peek = System.in.read();
digitNum++;
};
return new FloatNum(floatnum);
}
return new Num(num);
}
if(peek=='.'){
peek = System.in.read();
if(Character.isDigit(peek)){
double floatnum=0;
int digitNum = 1;
while (Character.isDigit(peek)) {
floatnum = floatnum + Character.digit(peek, 10)
* Math.pow(0.1, digitNum);
peek = System.in.read();
digitNum++;
};
return new FloatNum(floatnum);
}else{
return new Token('.');
}
}
// 处理保留字和标识符
if (Character.isLetter(peek)) {
// 缓冲字符
StringBuffer sb = new StringBuffer();
do {
sb.append((char) peek);
peek = System.in.read();
} while (Character.isLetter(peek));
String s = sb.toString();
// 如果已经在保留字表中,则返回,否则创建新的Word对象
Word word = reverseWord.get(s);
if (word != null) {
return word;
}
word = new Word(Tag.ID, s);
// 存入新的标识符
reverseWord.put(s, word);
return word;
}
Token t = new Token(peek);
peek = ' ';
return t;
}
public static void main(String[] args) throws IOException {
Lexer l = new Lexer();
while (true) {
Token scan = l.scan();
if (scan instanceof Num) {
System.out.println("num:" + ((Num) scan).getValue());
} else if (scan instanceof Word) {
System.out.println("word:" + ((Word) scan).getExpression());
} else if (scan instanceof Operator) {
System.out.println("operator:"
+ ((Operator) scan).getOperator());
}else if (scan instanceof FloatNum) {
System.out.println("float:"
+ ((FloatNum) scan).getValue());
} else {
System.out.println("tag:" + (char) scan.getTag());
}
}
}
}
package afterExpression;
public class FloatNum extends Token{
private final double value;
public FloatNum(double value) {
super(Tag.FLOAT_NUM);
this.value=value;
}
public double getValue() {
return value;
}
}
package afterExpression;
public class Operator extends Token{
private final String operator;
public Operator(int t,String operator) {
super(t);
this.operator=operator;
}
public String getOperator() {
return operator;
}
}
2.8.1
class For extends Stmt{
Expr expr1;
Expr expr2;
Expr expr3;
Stmt stmt;
While w;
public For(Expr expr1,Expr expr2,Expr expr3,Stmt stmt){
this.expr1=expr1;
this.expr2=expr2;
this.expr3=expr3;
this.stmt=stmt;
Stmt stmts=new Seq(stmt,expr3);
w=new While(expr2,stmts);
}
public void gen(){
Expr n=expr1.rvalue();
w.gen();
}
}
2.8.2 可以用0和1表示哟。。