use of priv.bajdcc.OP.syntax.handler.SyntaxException in project jMiniLang by bajdcc.
the class TestGrammar method main.
public static void main(String[] args) {
// System.out.println("Z -> `a`<,> | B | [`a` `b` Z B]");
try {
// Scanner scanner = new Scanner(System.in);
Grammar grammar = new Grammar("3 - (28 / (4 * 7)) * (2 + 4) + 5");
grammar.addTerminal("i", TokenType.INTEGER, null);
grammar.addTerminal("PLUS", TokenType.OPERATOR, OperatorType.PLUS);
grammar.addTerminal("MINUS", TokenType.OPERATOR, OperatorType.MINUS);
grammar.addTerminal("TIMES", TokenType.OPERATOR, OperatorType.TIMES);
grammar.addTerminal("DIVIDE", TokenType.OPERATOR, OperatorType.DIVIDE);
grammar.addTerminal("LPA", TokenType.OPERATOR, OperatorType.LPARAN);
grammar.addTerminal("RPA", TokenType.OPERATOR, OperatorType.RPARAN);
String[] nons = new String[] { "E", "T", "F" };
for (String non : nons) {
grammar.addNonTerminal(non);
}
grammar.addPatternHandler("1", new IPatternHandler() {
@Override
public Object handle(List<Token> tokens, List<Object> symbols) {
return Integer.parseInt(tokens.get(0).object.toString());
}
@Override
public String getPatternName() {
return "操作数转换";
}
});
grammar.addPatternHandler("010", new IPatternHandler() {
@Override
public Object handle(List<Token> tokens, List<Object> symbols) {
int lop = (int) symbols.get(0);
int rop = (int) symbols.get(1);
Token op = tokens.get(0);
if (op.kToken == TokenType.OPERATOR) {
OperatorType kop = (OperatorType) op.object;
switch(kop) {
case PLUS:
return lop + rop;
case MINUS:
return lop - rop;
case TIMES:
return lop * rop;
case DIVIDE:
if (rop == 0) {
return lop;
} else {
return lop / rop;
}
default:
return 0;
}
} else {
return 0;
}
}
@Override
public String getPatternName() {
return "二元运算";
}
});
grammar.addPatternHandler("101", new IPatternHandler() {
@Override
public Object handle(List<Token> tokens, List<Object> symbols) {
Token ltok = tokens.get(0);
Token rtok = tokens.get(1);
Object exp = symbols.get(0);
if (ltok.object == OperatorType.LPARAN && rtok.object == OperatorType.RPARAN) {
// 判断括号
return exp;
}
return null;
}
@Override
public String getPatternName() {
return "括号运算";
}
});
grammar.infer("E -> E @PLUS T | E @MINUS T | T");
grammar.infer("T -> T @TIMES F | T @DIVIDE F | F");
grammar.infer("F -> @LPA E @RPA | @i");
grammar.initialize("E");
System.out.println(grammar.getPrecedenceString());
System.out.println(grammar.toString());
grammar.run();
System.out.println(grammar.getTokenString());
// scanner.close();
} catch (RegexException e) {
System.err.println(e.getPosition() + "," + e.getMessage());
e.printStackTrace();
} catch (SyntaxException e) {
System.err.println(e.getPosition() + "," + e.getMessage() + " " + e.getInfo());
e.printStackTrace();
} catch (GrammarException e) {
System.err.println(e.getPosition() + "," + e.getMessage() + " " + e.getInfo());
e.printStackTrace();
}
}
use of priv.bajdcc.OP.syntax.handler.SyntaxException in project jMiniLang by bajdcc.
the class TestGrammar2 method main.
public static void main(String[] args) {
// System.out.println("Z -> `a`<,> | B | [`a` `b` Z B]");
try {
// Scanner scanner = new Scanner(System.in);
Grammar grammar = new Grammar("!3 - (28 / (!4 * 7)) * (2 + 4) + 5");
grammar.addTerminal("i", TokenType.INTEGER, null);
grammar.addTerminal("NEGATIVE", TokenType.OPERATOR, OperatorType.LOGICAL_NOT);
grammar.addTerminal("PLUS", TokenType.OPERATOR, OperatorType.PLUS);
grammar.addTerminal("MINUS", TokenType.OPERATOR, OperatorType.MINUS);
grammar.addTerminal("TIMES", TokenType.OPERATOR, OperatorType.TIMES);
grammar.addTerminal("DIVIDE", TokenType.OPERATOR, OperatorType.DIVIDE);
grammar.addTerminal("LPA", TokenType.OPERATOR, OperatorType.LPARAN);
grammar.addTerminal("RPA", TokenType.OPERATOR, OperatorType.RPARAN);
String[] nons = new String[] { "E", "T", "F", "G" };
for (String non : nons) {
grammar.addNonTerminal(non);
}
grammar.addPatternHandler("1", new IPatternHandler() {
@Override
public Object handle(List<Token> tokens, List<Object> symbols) {
return Integer.parseInt(tokens.get(0).object.toString());
}
@Override
public String getPatternName() {
return "操作数转换";
}
});
grammar.addPatternHandler("010", new IPatternHandler() {
@Override
public Object handle(List<Token> tokens, List<Object> symbols) {
int lop = (int) symbols.get(0);
int rop = (int) symbols.get(1);
Token op = tokens.get(0);
if (op.kToken == TokenType.OPERATOR) {
OperatorType kop = (OperatorType) op.object;
switch(kop) {
case PLUS:
return lop + rop;
case MINUS:
return lop - rop;
case TIMES:
return lop * rop;
case DIVIDE:
if (rop == 0) {
return lop;
} else {
return lop / rop;
}
default:
return 0;
}
} else {
return 0;
}
}
@Override
public String getPatternName() {
return "二元运算";
}
});
grammar.addPatternHandler("101", new IPatternHandler() {
@Override
public Object handle(List<Token> tokens, List<Object> symbols) {
Token ltok = tokens.get(0);
Token rtok = tokens.get(1);
Object exp = symbols.get(0);
if (ltok.object == OperatorType.LPARAN && rtok.object == OperatorType.RPARAN) {
// 判断括号
return exp;
}
return null;
}
@Override
public String getPatternName() {
return "括号运算";
}
});
grammar.addPatternHandler("10", new IPatternHandler() {
@Override
public Object handle(List<Token> tokens, List<Object> symbols) {
Token unary = tokens.get(0);
int op = (int) symbols.get(0);
if (unary.object == OperatorType.LOGICAL_NOT) {
// 判断取反
return -op;
}
return null;
}
@Override
public String getPatternName() {
return "一元运算";
}
});
grammar.infer("E -> E @PLUS T | E @MINUS T | T");
grammar.infer("T -> T @TIMES F | T @DIVIDE F | F");
grammar.infer("F -> @NEGATIVE G | G");
grammar.infer("G -> @LPA E @RPA | @i");
grammar.initialize("E");
System.out.println(grammar.getPrecedenceString());
System.out.println(grammar.toString());
grammar.run();
System.out.println(grammar.getTokenString());
// scanner.close();
} catch (RegexException e) {
System.err.println(e.getPosition() + "," + e.getMessage());
e.printStackTrace();
} catch (SyntaxException e) {
System.err.println(e.getPosition() + "," + e.getMessage() + " " + e.getInfo());
e.printStackTrace();
} catch (GrammarException e) {
System.err.println(e.getPosition() + "," + e.getMessage() + " " + e.getInfo());
e.printStackTrace();
}
}
use of priv.bajdcc.OP.syntax.handler.SyntaxException in project jMiniLang by bajdcc.
the class TestSyntax method main.
public static void main(String[] args) {
// System.out.println("Z -> `a`<,> | B | [`a` `b` Z B]");
try {
// Scanner scanner = new Scanner(System.in);
Syntax syntax = new Syntax();
syntax.addTerminal("SYMBOL", TokenType.ID, "i");
syntax.addTerminal("PLUS", TokenType.OPERATOR, OperatorType.PLUS);
syntax.addTerminal("MINUS", TokenType.OPERATOR, OperatorType.MINUS);
syntax.addTerminal("TIMES", TokenType.OPERATOR, OperatorType.TIMES);
syntax.addTerminal("DIVIDE", TokenType.OPERATOR, OperatorType.DIVIDE);
syntax.addTerminal("LPA", TokenType.OPERATOR, OperatorType.LPARAN);
syntax.addTerminal("RPA", TokenType.OPERATOR, OperatorType.RPARAN);
String[] nons = new String[] { "E", "T", "F" };
for (String non : nons) {
syntax.addNonTerminal(non);
}
syntax.infer("E -> E @PLUS T | E @MINUS T | T");
syntax.infer("T -> T @MINUS F | T @DIVIDE F | F");
syntax.infer("F -> @LPA E @RPA | @SYMBOL");
syntax.initialize("E");
System.out.println(syntax.toString());
// scanner.close();
} catch (RegexException e) {
System.err.println(e.getPosition() + "," + e.getMessage());
e.printStackTrace();
} catch (SyntaxException e) {
System.err.println(e.getPosition() + "," + e.getMessage() + " " + e.getInfo());
e.printStackTrace();
}
}
use of priv.bajdcc.OP.syntax.handler.SyntaxException in project jMiniLang by bajdcc.
the class ModuleTask method util_calc.
private static String util_calc(String expr) {
try {
priv.bajdcc.OP.grammar.Grammar grammar = new priv.bajdcc.OP.grammar.Grammar(expr);
grammar.addTerminal("i", TokenType.INTEGER, null);
grammar.addTerminal("PLUS", TokenType.OPERATOR, OperatorType.PLUS);
grammar.addTerminal("MINUS", TokenType.OPERATOR, OperatorType.MINUS);
grammar.addTerminal("TIMES", TokenType.OPERATOR, OperatorType.TIMES);
grammar.addTerminal("DIVIDE", TokenType.OPERATOR, OperatorType.DIVIDE);
grammar.addTerminal("LPA", TokenType.OPERATOR, OperatorType.LPARAN);
grammar.addTerminal("RPA", TokenType.OPERATOR, OperatorType.RPARAN);
String[] nons = new String[] { "E", "T", "F" };
for (String non : nons) {
grammar.addNonTerminal(non);
}
grammar.addPatternHandler("1", new IPatternHandler() {
@Override
public Object handle(List<Token> tokens, List<Object> symbols) {
return Integer.parseInt(tokens.get(0).object.toString());
}
@Override
public String getPatternName() {
return "操作数转换";
}
});
grammar.addPatternHandler("010", new IPatternHandler() {
@Override
public Object handle(List<Token> tokens, List<Object> symbols) {
int lop = (int) symbols.get(0);
int rop = (int) symbols.get(1);
Token op = tokens.get(0);
if (op.kToken == TokenType.OPERATOR) {
OperatorType kop = (OperatorType) op.object;
switch(kop) {
case PLUS:
return lop + rop;
case MINUS:
return lop - rop;
case TIMES:
return lop * rop;
case DIVIDE:
if (rop == 0) {
return lop;
} else {
return lop / rop;
}
default:
return 0;
}
} else {
return 0;
}
}
@Override
public String getPatternName() {
return "二元运算";
}
});
grammar.addPatternHandler("101", new IPatternHandler() {
@Override
public Object handle(List<Token> tokens, List<Object> symbols) {
Token ltok = tokens.get(0);
Token rtok = tokens.get(1);
Object exp = symbols.get(0);
if (ltok.object == OperatorType.LPARAN && rtok.object == OperatorType.RPARAN) {
// 判断括号
return exp;
}
return null;
}
@Override
public String getPatternName() {
return "括号运算";
}
});
grammar.infer("E -> E @PLUS T | E @MINUS T | T");
grammar.infer("T -> T @TIMES F | T @DIVIDE F | F");
grammar.infer("F -> @LPA E @RPA | @i");
grammar.initialize("E");
return String.valueOf(grammar.run());
} catch (RegexException e) {
logger.error("#CALC# Error: " + e.getPosition() + "," + e.getMessage());
} catch (SyntaxException e) {
logger.error("#CALC#Error: " + e.getPosition() + "," + e.getMessage() + " " + e.getInfo());
} catch (GrammarException e) {
logger.error("#CALC#Error: " + e.getPosition() + "," + e.getMessage() + " " + e.getInfo());
}
return "#CALC#Error";
}
Aggregations