(1) Event unterminated_case: The case for value "'F'" is not terminated by a "break" statement. Also see events: [fallthrough]
时间: 2024-03-19 19:41:28 浏览: 81
这是一个编程错误,表示在一个 switch 语句中,当匹配到某个 case 分支时,没有使用 break 语句来终止该分支的执行,导致代码会继续执行下面的分支,这可能会引起意想不到的结果。解决这个问题的方法是在每个 case 分支的最后添加一个 break 语句来终止该分支的执行。如果需要让多个分支共享一些代码,可以使用 fallthrough 关键字来实现。
相关问题
You are to write a lexical analyzer/scanner for the language decaf in java. Goals: 1. The input of the scanner is a source code file and the output of the scanner is a stream of tokens. 2. Your scanner should go for longest possible match i.e. a string ‘:=’is to be identified as ‘ass-symbol’ and not as ‘:’and ‘=’. 3. Token is represented as (Kind, Value). We use the following symbols to denote different kinds of tokens KEY denotes reserved words SYM denotes special symbols ID denotes identifiers NUM denotes numeric constants STR denotes string constants 4. Check lexical errors: giving meaning error messages and the lines where errors occur. The kinds of lexical errors are: - Illegal character, that is, scanner may recognize a character that is not in the alphabet of TINY+ - The right bracket of a STRING is lost - The right delimiter of a comment is lost
Sure, I can help you with that! Here's a sample code for a lexical analyzer/scanner for the decaf language in Java:
```
import java.io.*;
import java.util.*;
public class Scanner {
private BufferedReader br;
private char currentChar;
private int currentLineNum;
private String currentTokenValue;
// reserved words
private static final Map<String, Token.Kind> reservedWords = new HashMap<>();
static {
reservedWords.put("class", Token.Kind.CLASS);
reservedWords.put("extends", Token.Kind.EXTENDS);
reservedWords.put("static", Token.Kind.STATIC);
reservedWords.put("void", Token.Kind.VOID);
reservedWords.put("main", Token.Kind.MAIN);
reservedWords.put("public", Token.Kind.PUBLIC);
reservedWords.put("private", Token.Kind.PRIVATE);
reservedWords.put("int", Token.Kind.INT);
reservedWords.put("boolean", Token.Kind.BOOLEAN);
reservedWords.put("if", Token.Kind.IF);
reservedWords.put("else", Token.Kind.ELSE);
reservedWords.put("while", Token.Kind.WHILE);
reservedWords.put("return", Token.Kind.RETURN);
reservedWords.put("true", Token.Kind.TRUE);
reservedWords.put("false", Token.Kind.FALSE);
reservedWords.put("this", Token.Kind.THIS);
reservedWords.put("new", Token.Kind.NEW);
}
// special symbols
private static final Map<String, Token.Kind> specialSymbols = new HashMap<>();
static {
specialSymbols.put("(", Token.Kind.LPAREN);
specialSymbols.put(")", Token.Kind.RPAREN);
specialSymbols.put("{", Token.Kind.LBRACE);
specialSymbols.put("}", Token.Kind.RBRACE);
specialSymbols.put("[", Token.Kind.LBRACKET);
specialSymbols.put("]", Token.Kind.RBRACKET);
specialSymbols.put(".", Token.Kind.DOT);
specialSymbols.put(",", Token.Kind.COMMA);
specialSymbols.put(";", Token.Kind.SEMICOLON);
specialSymbols.put("=", Token.Kind.ASSIGN);
specialSymbols.put("!", Token.Kind.NOT);
specialSymbols.put("&", Token.Kind.AND);
specialSymbols.put("|", Token.Kind.OR);
specialSymbols.put("<", Token.Kind.LT);
specialSymbols.put(">", Token.Kind.GT);
specialSymbols.put("==", Token.Kind.EQUAL);
specialSymbols.put("!=", Token.Kind.NOTEQUAL);
specialSymbols.put("<=", Token.Kind.LE);
specialSymbols.put(">=", Token.Kind.GE);
specialSymbols.put("+", Token.Kind.ADD);
specialSymbols.put("-", Token.Kind.SUB);
specialSymbols.put("*", Token.Kind.MUL);
specialSymbols.put("/", Token.Kind.DIV);
specialSymbols.put("%", Token.Kind.MOD);
}
public Scanner(String filename) throws IOException {
br = new BufferedReader(new FileReader(filename));
currentLineNum = 1;
currentChar = (char) br.read();
}
private void getNextChar() throws IOException {
if (currentChar == '\n') {
currentLineNum++;
}
currentChar = (char) br.read();
}
private boolean isWhitespace(char c) {
return c == ' ' || c == '\t' || c == '\r' || c == '\n';
}
private boolean isDigit(char c) {
return c >= '0' && c <= '9';
}
private boolean isLetter(char c) {
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
}
private boolean isLegalCharacter(char c) {
return isWhitespace(c) || isDigit(c) || isLetter(c) || specialSymbols.containsKey(Character.toString(c));
}
private void skipWhitespace() throws IOException {
while (isWhitespace(currentChar)) {
getNextChar();
}
}
private Token scanIdentifierOrKeyword() throws IOException {
StringBuilder sb = new StringBuilder();
while (isLetter(currentChar) || isDigit(currentChar) || currentChar == '_') {
sb.append(currentChar);
getNextChar();
}
String tokenValue = sb.toString();
Token.Kind kind = reservedWords.getOrDefault(tokenValue, Token.Kind.ID);
return new Token(kind, tokenValue, currentLineNum);
}
private Token scanNumber() throws IOException {
StringBuilder sb = new StringBuilder();
while (isDigit(currentChar)) {
sb.append(currentChar);
getNextChar();
}
String tokenValue = sb.toString();
return new Token(Token.Kind.NUM, tokenValue, currentLineNum);
}
private Token scanString() throws IOException {
StringBuilder sb = new StringBuilder();
getNextChar();
while (currentChar != '"') {
if (currentChar == '\n' || currentChar == -1) {
throw new LexicalException("Unterminated string", currentLineNum);
}
sb.append(currentChar);
getNextChar();
}
getNextChar();
return new Token(Token.Kind.STR, sb.toString(), currentLineNum);
}
private Token scanComment() throws IOException {
getNextChar();
getNextChar();
while (!(currentChar == '*' && br.read() == '/')) {
if (currentChar == '\n') {
currentLineNum++;
}
getNextChar();
}
getNextChar();
return getNextToken();
}
private Token scanSpecialSymbol() throws IOException {
StringBuilder sb = new StringBuilder();
while (specialSymbols.containsKey(sb.toString() + currentChar)) {
sb.append(currentChar);
getNextChar();
}
String tokenValue = sb.toString();
Token.Kind kind = specialSymbols.get(tokenValue);
if (kind == null) {
throw new LexicalException("Illegal character: " + tokenValue, currentLineNum);
}
return new Token(kind, tokenValue, currentLineNum);
}
public Token getNextToken() throws IOException {
while (isWhitespace(currentChar)) {
skipWhitespace();
}
if (currentChar == -1) {
return new Token(Token.Kind.EOF, "", currentLineNum);
}
if (!isLegalCharacter(currentChar)) {
throw new LexicalException("Illegal character: " + currentChar, currentLineNum);
}
if (currentChar == '/') {
getNextChar();
if (currentChar == '/') {
while (currentChar != '\n' && currentChar != -1) {
getNextChar();
}
return getNextToken();
} else if (currentChar == '*') {
return scanComment();
} else {
return new Token(Token.Kind.DIV, "/", currentLineNum);
}
}
if (isLetter(currentChar)) {
return scanIdentifierOrKeyword();
}
if (isDigit(currentChar)) {
return scanNumber();
}
if (currentChar == '"') {
return scanString();
}
if (specialSymbols.containsKey(Character.toString(currentChar))) {
return scanSpecialSymbol();
}
throw new LexicalException("Illegal character: " + currentChar, currentLineNum);
}
public static class LexicalException extends RuntimeException {
private int lineNum;
public LexicalException(String message, int lineNum) {
super(message);
this.lineNum = lineNum;
}
public int getLineNum() {
return lineNum;
}
}
}
```
This code reads in a source code file and returns a stream of tokens. It uses a map to store the reserved words and special symbols, and uses a series of `if` statements to determine what kind of token it is dealing with. It also handles lexical errors by throwing a `LexicalException` with a meaningful error message and the line number where the error occurred.
Unresolved compilation problem: String literal is not properly closed by a double-quote
这个编译错误提示 "Unresolved compilation problem: String literal is not properly closed by a double-quote" 表示你在Java代码中创建了一个字符串字面量(string literal),即使用了双引号 (`"` 或 `""`) 定义的一个字符串,但是这个字符串没有正确地闭合。可能是少了一个结束的双引号,或者是字符串内容包含了开始但未包含结束的转义字符。
例如:
```java
String str = "This string is not closed"; // 缺少结束的'"
```
或者
```java
String str = "This \"is an unterminated string"; // 字符串内容包含未闭合的"
```
解决这个问题的方法是在合适的位置添加缺失的双引号,使其构成一个完整的字符串。正确的例子应该是:
```java
String str = "This string is properly closed\"";
```
或者
```java
String str = "This \"is now a closed string\"";
```
阅读全文