package aima.core.logic.fol.parsing;
import java.util.HashSet;
import java.util.Set;
import aima.core.logic.common.Lexer;
import aima.core.logic.common.LogicTokenTypes;
import aima.core.logic.common.Token;
import aima.core.logic.fol.Connectors;
import aima.core.logic.fol.Quantifiers;
import aima.core.logic.fol.domain.FOLDomain;
/**
* @author Ravi Mohan
*
*/
public class FOLLexer extends Lexer {
private FOLDomain domain;
private Set<String> connectors, quantifiers;
public FOLLexer(FOLDomain domain) {
this.domain = domain;
connectors = new HashSet<String>();
connectors.add(Connectors.NOT);
connectors.add(Connectors.AND);
connectors.add(Connectors.OR);
connectors.add(Connectors.IMPLIES);
connectors.add(Connectors.BICOND);
quantifiers = new HashSet<String>();
quantifiers.add(Quantifiers.FORALL);
quantifiers.add(Quantifiers.EXISTS);
}
public FOLDomain getFOLDomain() {
return domain;
}
@Override
public Token nextToken() {
if (lookAhead(1) == '(') {
consume();
return new Token(LogicTokenTypes.LPAREN, "(");
} else if (lookAhead(1) == ')') {
consume();
return new Token(LogicTokenTypes.RPAREN, ")");
} else if (lookAhead(1) == ',') {
consume();
return new Token(LogicTokenTypes.COMMA, ",");
} else if (identifierDetected()) {
// System.out.println("identifier detected");
return identifier();
} else if (Character.isWhitespace(lookAhead(1))) {
consume();
return nextToken();
} else if (lookAhead(1) == (char) -1) {
return new Token(LogicTokenTypes.EOI, "EOI");
} else {
throw new RuntimeException("Lexing error on character "
+ lookAhead(1));
}
}
private Token identifier() {
StringBuffer sbuf = new StringBuffer();
while ((Character.isJavaIdentifierPart(lookAhead(1)))
|| partOfConnector()) {
sbuf.append(lookAhead(1));
consume();
}
String readString = new String(sbuf);
// System.out.println(readString);
if (connectors.contains(readString)) {
return new Token(LogicTokenTypes.CONNECTOR, readString);
} else if (quantifiers.contains(readString)) {
return new Token(LogicTokenTypes.QUANTIFIER, readString);
} else if (domain.getPredicates().contains(readString)) {
return new Token(LogicTokenTypes.PREDICATE, readString);
} else if (domain.getFunctions().contains(readString)) {
return new Token(LogicTokenTypes.FUNCTION, readString);
} else if (domain.getConstants().contains(readString)) {
return new Token(LogicTokenTypes.CONSTANT, readString);
} else if (isVariable(readString)) {
return new Token(LogicTokenTypes.VARIABLE, readString);
} else if (readString.equals("=")) {
return new Token(LogicTokenTypes.EQUALS, readString);
} else {
throw new RuntimeException("Lexing error on character "
+ lookAhead(1));
}
}
private boolean isVariable(String s) {
return (Character.isLowerCase(s.charAt(0)));
}
private boolean identifierDetected() {
return (Character.isJavaIdentifierStart((char) lookAheadBuffer[0]))
|| partOfConnector();
}
private boolean partOfConnector() {
return (lookAhead(1) == '=') || (lookAhead(1) == '<')
|| (lookAhead(1) == '>');
}
}