repo
stringlengths 1
191
⌀ | file
stringlengths 23
351
| code
stringlengths 0
5.32M
| file_length
int64 0
5.32M
| avg_line_length
float64 0
2.9k
| max_line_length
int64 0
288k
| extension_type
stringclasses 1
value |
|---|---|---|---|---|---|---|
jkind
|
jkind-master/jkind-api/src/jkind/api/eclipse/JRealizabilityApi.java
|
package jkind.api.eclipse;
import java.io.File;
import org.eclipse.core.runtime.IProgressMonitor;
import jkind.api.results.JRealizabilityResult;
import jkind.lustre.Program;
public class JRealizabilityApi extends jkind.api.JRealizabilityApi {
/**
* Run JRealizability on a Lustre program
*
* @param program
* Lustre program
* @param result
* Place to store results as they come in
* @param monitor
* Used to check for cancellation
* @throws jkind.JKindException
*/
@Override
public void execute(Program program, JRealizabilityResult result, IProgressMonitor monitor) {
execute(program.toString(), result, monitor);
}
/**
* Run JRealizability on a Lustre program
*
* @param program
* Lustre program as text
* @param result
* Place to store results as they come in
* @param monitor
* Used to check for cancellation
* @throws jkind.JKindException
*/
@Override
public void execute(String program, JRealizabilityResult result, IProgressMonitor monitor) {
execute(program, result, new jkind.api.eclipse.ApiUtil.CancellationMonitor(monitor));
}
/**
* Run JRealizability on a Lustre program
*
* @param lustreFile
* File containing Lustre program
* @param result
* Place to store results as they come in
* @param monitor
* Used to check for cancellation
* @throws jkind.JKindException
*/
@Override
public void execute(File lustreFile, JRealizabilityResult result, IProgressMonitor monitor) {
execute(lustreFile, result, new jkind.api.eclipse.ApiUtil.CancellationMonitor(monitor));
}
}
| 1,661
| 26.245902
| 94
|
java
|
jkind
|
jkind-master/jkind-api/src/jkind/api/eclipse/JKindApi.java
|
package jkind.api.eclipse;
import java.io.File;
import org.eclipse.core.runtime.IProgressMonitor;
import jkind.api.results.JKindResult;
public class JKindApi extends jkind.api.JKindApi {
/**
* Run JKind on a Lustre program
*
* @param lustreFile
* File containing Lustre program
* @param result
* Place to store results as they come in
* @param monitor
* Used to check for cancellation
* @throws jkind.JKindException
*/
@Override
public void execute(File lustreFile, JKindResult result, IProgressMonitor monitor) {
execute(lustreFile, result, new jkind.api.eclipse.ApiUtil.CancellationMonitor(monitor));
}
}
| 672
| 23.035714
| 90
|
java
|
jkind
|
jkind-master/jkind-api/src/jkind/api/workarounds/WorkaroundKind2ForwardReference.java
|
package jkind.api.workarounds;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import jkind.lustre.NamedType;
import jkind.lustre.Program;
import jkind.lustre.Type;
import jkind.lustre.TypeDef;
import jkind.lustre.builders.ProgramBuilder;
import jkind.lustre.visitors.TypeIterVisitor;
import jkind.util.TopologicalSorter;
public class WorkaroundKind2ForwardReference {
public static Program program(Program program) {
ProgramBuilder bulider = new ProgramBuilder(program);
bulider.clearTypes().addTypes(getSortedTypes(program.types));
return bulider.build();
}
private static List<TypeDef> getSortedTypes(List<TypeDef> types) {
TopologicalSorter<TypeDef> sorter = new TopologicalSorter<>();
for (TypeDef type : types) {
sorter.put(type.id, type, getTypeDependencies(type.type));
}
return sorter.getSortedValues();
}
private static Set<String> getTypeDependencies(Type type) {
final Set<String> dependencies = new HashSet<>();
type.accept(new TypeIterVisitor() {
@Override
public Void visit(NamedType e) {
if (!e.isBuiltin()) {
dependencies.add(e.name);
}
return null;
}
});
return dependencies;
}
}
| 1,183
| 25.909091
| 67
|
java
|
jkind
|
jkind-master/jkind/src/jkind/Benchmark.java
|
package jkind;
import java.io.File;
import java.io.FileWriter;
import java.io.FilenameFilter;
import java.lang.ProcessBuilder.Redirect;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import jkind.util.Util;
public class Benchmark {
private static final File LOG = new File("results.log");
private static int N = 1;
public static void main(String args[]) {
try {
LOG.delete();
if (args.length >= 2 && "-N".equals(args[0])) {
N = Integer.parseInt(args[1]);
args = Arrays.copyOfRange(args, 2, args.length);
}
System.out.println("Arguments: " + join(args));
System.out.println();
System.out.println("File, Runtime");
for (String file : getFiles()) {
System.out.printf("%s, %.1f", file, getMedianRuntime(args, file));
System.out.println();
}
} catch (Throwable t) {
t.printStackTrace();
System.exit(ExitCodes.UNCAUGHT_EXCEPTION);
}
}
private static String[] getFiles() {
return new File(".").list(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
return name.endsWith(".lus");
}
});
}
private static String join(String[] strings) {
StringBuilder buf = new StringBuilder();
for (String string : strings) {
buf.append(string);
buf.append(" ");
}
return buf.toString();
}
private static double getMedianRuntime(String[] fixedArgs, String file) throws Exception {
List<String> args = new ArrayList<>();
if (Util.isWindows()) {
args.add("cmd");
args.add("/c");
}
args.add("jkind");
args.addAll(Arrays.asList(fixedArgs));
args.add(file);
List<Double> results = new ArrayList<>();
for (int i = 0; i < N; i++) {
results.add(getRuntime(args));
}
return median(results);
}
private static double getRuntime(List<String> args) throws Exception {
ProcessBuilder pb = new ProcessBuilder(args);
pb.redirectErrorStream(true);
pb.redirectOutput(Redirect.appendTo(LOG));
try (FileWriter out = new FileWriter(LOG, true)) {
out.write(args.toString());
out.write(System.lineSeparator());
out.close();
}
long start = System.nanoTime();
Process process = pb.start();
process.waitFor();
long stop = System.nanoTime();
return (stop - start) / 1000.0 / 1000.0 / 1000.0;
}
private static double median(List<Double> results) {
Collections.sort(results);
int n = results.size();
if (n % 2 == 1) {
return results.get(n / 2);
} else {
return (results.get(n / 2) + results.get(n / 2 - 1)) / 2;
}
}
}
| 2,540
| 22.971698
| 91
|
java
|
jkind
|
jkind-master/jkind/src/jkind/Main.java
|
package jkind;
import java.io.File;
import java.io.IOException;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.antlr.v4.runtime.ANTLRFileStream;
import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.CommonTokenStream;
import jkind.lustre.ArrayType;
import jkind.lustre.Node;
import jkind.lustre.Program;
import jkind.lustre.RecordType;
import jkind.lustre.VarDecl;
import jkind.lustre.parsing.FlattenIds;
import jkind.lustre.parsing.LustreLexer;
import jkind.lustre.parsing.LustreParseException;
import jkind.lustre.parsing.LustreParser;
import jkind.lustre.parsing.LustreParser.ProgramContext;
import jkind.lustre.parsing.LustreToAstVisitor;
import jkind.lustre.parsing.StdErrErrorListener;
import jkind.lustre.parsing.ValidIdChecker;
import jkind.util.Util;
/**
* This class serves as a single entry point for all JKind-based command line
* tools. This allows us to distribute a single jar for all tools. It would not
* be enough to simply put this jar is the classpath and load the appropriate
* main, because we rely on some third-party jars which Java is not able to load
* out of another jar. Instead, we use Eclipse's "Export to Runnable JAR"
* feature which comes with a jar-in-jar loader. The downside is that such
* runnable JARs allow only a single entry point.
*/
public class Main {
public static final String getVersion() {
Package p = Main.class.getPackage();
return ((p != null) ? p.getImplementationVersion() : "UNKNOWN");
}
public static void main(String[] args) {
String availableEntryPoints = "Available entry points: -jkind, -jlustre2kind, -jlustre2excel, -jrealizability, -benchmark";
if (args.length == 0) {
StdErr.println("JKind Suite " + getVersion());
StdErr.println(availableEntryPoints);
System.exit(0);
}
String entryPoint = args[0];
String[] subArgs = Arrays.copyOfRange(args, 1, args.length);
switch (entryPoint) {
case "-jkind":
JKind.main(subArgs);
break;
case "-jlustre2kind":
JLustre2Kind.main(subArgs);
break;
case "-jlustre2excel":
JLustre2Excel.main(subArgs);
break;
case "-jrealizability":
JRealizability.main(subArgs);
break;
case "-benchmark":
Benchmark.main(subArgs);
break;
default:
StdErr.error("unknown entry point: " + entryPoint);
StdErr.println(availableEntryPoints);
System.exit(ExitCodes.UNKNOWN_ENTRY_POINT);
}
}
public static Program parseLustre(String filename) throws Exception {
File file = new File(filename);
if (!file.exists() || !file.isFile()) {
StdErr.fatal(ExitCodes.FILE_NOT_FOUND, "cannot find file " + filename);
}
if (!file.canRead()) {
StdErr.fatal(ExitCodes.FILE_NOT_READABLE, "cannot read file " + filename);
}
StdErr.setLocationReference(readAllLines(filename));
return parseLustre(new ANTLRFileStream(filename));
}
private static List<String> readAllLines(String filename) {
Path path = FileSystems.getDefault().getPath(filename);
try {
return Files.readAllLines(path);
} catch (IOException e) {
return Collections.emptyList();
}
}
public static Program parseLustre(CharStream stream) throws Exception {
LustreLexer lexer = new LustreLexer(stream);
CommonTokenStream tokens = new CommonTokenStream(lexer);
LustreParser parser = new LustreParser(tokens);
parser.removeErrorListeners();
parser.addErrorListener(new StdErrErrorListener());
ProgramContext program = parser.program();
if (parser.getNumberOfSyntaxErrors() > 0) {
System.exit(ExitCodes.PARSE_ERROR);
}
try {
return flattenOrCheck(new LustreToAstVisitor().program(program));
} catch (LustreParseException e) {
StdErr.fatal(ExitCodes.PARSE_ERROR, e.getLocation(), e.getMessage());
throw e;
}
}
/**
* We allow extended ids (with ~ [ ] .) only when the program is a single
* node with simple types. This is useful for working with output from
* JLustre2Kind.
*/
private static Program flattenOrCheck(Program program) {
if (isSimple(program)) {
return new FlattenIds().visit(program);
} else {
if (!ValidIdChecker.check(program)) {
System.exit(ExitCodes.PARSE_ERROR);
}
return program;
}
}
private static boolean isSimple(Program program) {
if (!program.types.isEmpty()) {
return false;
} else if (!program.constants.isEmpty()) {
return false;
} else if (program.nodes.size() != 1) {
return false;
}
Node main = program.getMainNode();
for (VarDecl vd : Util.getVarDecls(main)) {
if (vd.type instanceof ArrayType || vd.type instanceof RecordType) {
return false;
}
}
return true;
}
}
| 4,710
| 28.080247
| 125
|
java
|
jkind
|
jkind-master/jkind/src/jkind/JLustre2Kind.java
|
package jkind;
import java.io.File;
import jkind.analysis.StaticAnalyzer;
import jkind.jlustre2kind.KindEncodeIdsVisitor;
import jkind.jlustre2kind.ObfuscateIdsVisitor;
import jkind.lustre.Node;
import jkind.lustre.Program;
import jkind.lustre.builders.NodeBuilder;
import jkind.lustre.builders.ProgramBuilder;
import jkind.slicing.DependencyMap;
import jkind.slicing.LustreSlicer;
import jkind.translation.RemoveEnumTypes;
import jkind.translation.Translate;
import jkind.util.Util;
public class JLustre2Kind {
public static void main(String args[]) {
try {
JLustre2KindSettings settings = JLustre2KindArgumentParser.parse(args);
String filename = settings.filename;
if (!filename.toLowerCase().endsWith(".lus")) {
StdErr.error("input file must have .lus extension");
}
String outFilename = filename.substring(0, filename.length() - 4) + ".kind.lus";
Program program = Main.parseLustre(filename);
StaticAnalyzer.check(program, SolverOption.Z3, settings);
program = Translate.translate(program);
program = RemoveEnumTypes.program(program);
Node main = program.getMainNode();
main = LustreSlicer.slice(main, new DependencyMap(main, main.properties, program.functions));
if (settings.encode) {
main = new KindEncodeIdsVisitor().visit(main);
}
if (settings.obfuscate) {
main = new ObfuscateIdsVisitor().visit(main);
main = new NodeBuilder(main).setId("main").build();
}
program = new ProgramBuilder(program).clearNodes().addNode(main).build();
if (settings.stdout) {
System.out.println(program.toString());
} else {
Util.writeToFile(program.toString(), new File(outFilename));
System.out.println("Wrote " + outFilename);
}
} catch (Throwable t) {
t.printStackTrace();
System.exit(ExitCodes.UNCAUGHT_EXCEPTION);
}
}
}
| 1,823
| 29.4
| 96
|
java
|
jkind
|
jkind-master/jkind/src/jkind/JKind.java
|
package jkind;
import jkind.analysis.LinearChecker;
import jkind.analysis.StaticAnalyzer;
import jkind.engines.Director;
import jkind.engines.SolverUtil;
import jkind.lustre.Node;
import jkind.lustre.Program;
import jkind.lustre.builders.ProgramBuilder;
import jkind.translation.InlineSimpleEquations;
import jkind.translation.Specification;
import jkind.translation.Translate;
public class JKind {
public static void main(String[] args) {
try {
JKindSettings settings = JKindArgumentParser.parse(args);
Program program = Main.parseLustre(settings.filename);
program = setMainNode(program, settings.main);
StaticAnalyzer.check(program, settings.solver, settings);
if (!LinearChecker.isLinear(program)) {
if (settings.pdrMax > 0) {
StdErr.warning("PDR not available for some properties due to non-linearities");
}
}
ensureSolverAvailable(settings.solver);
program = Translate.translate(program);
Node main = program.getMainNode();
Specification userSpec = new Specification(program, settings.slicing);
Specification analysisSpec = getAnalysisSpec(userSpec, settings);
int exitCode = new Director(settings, userSpec, analysisSpec).run();
System.exit(exitCode); // Kills all threads
} catch (Throwable t) {
t.printStackTrace();
System.exit(ExitCodes.UNCAUGHT_EXCEPTION);
}
}
private static Program setMainNode(Program program, String main) {
if (main == null) {
return program;
}
boolean hasMainNode = program.nodes.stream().anyMatch(n -> n.id.equals(main));
if (!hasMainNode) {
StdErr.fatal(ExitCodes.INVALID_OPTIONS, "Unable to find main node '" + main + "'");
}
return new ProgramBuilder(program).setMain(main).build();
}
private static void ensureSolverAvailable(SolverOption solver) {
try {
SolverUtil.getBasicSolver(solver);
} catch (JKindException e) {
StdErr.fatal(ExitCodes.INVALID_OPTIONS, e.getMessage());
}
}
private static Specification getAnalysisSpec(Specification userSpec, JKindSettings settings) {
if (settings.inlining) {
Node inlined = InlineSimpleEquations.node(userSpec.node);
Program program = new ProgramBuilder().addFunctions(userSpec.functions).addNode(inlined).build();
return new Specification(program, settings.slicing);
} else {
return userSpec;
}
}
}
| 2,310
| 30.22973
| 100
|
java
|
jkind
|
jkind-master/jkind/src/jkind/JLustre2KindSettings.java
|
package jkind;
public class JLustre2KindSettings extends Settings {
public boolean encode = false;
public boolean obfuscate = false;
public boolean stdout = false;
}
| 170
| 20.375
| 52
|
java
|
jkind
|
jkind-master/jkind/src/jkind/JRealizabilityArgumentParser.java
|
package jkind;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.Options;
public class JRealizabilityArgumentParser extends ArgumentParser {
private static final String EXCEL = "excel";
private static final String EXTEND_CEX = "extend_cex";
private static final String N = "n";
private static final String REDUCE = "reduce";
private static final String SCRATCH = "scratch";
private static final String TIMEOUT = "timeout";
private static final String XML = "xml";
private final JRealizabilitySettings settings;
private JRealizabilityArgumentParser() {
this("JRealizability", new JRealizabilitySettings());
}
private JRealizabilityArgumentParser(String name, JRealizabilitySettings settings) {
super(name, settings);
this.settings = settings;
}
@Override
protected Options getOptions() {
Options options = super.getOptions();
options.addOption(EXCEL, false, "generate results in Excel format");
options.addOption(EXTEND_CEX, false, "report extend counterexample");
options.addOption(N, true, "number of iterations (default 200)");
options.addOption(REDUCE, false, "reduce conflicting properties in case of unrealizable");
options.addOption(SCRATCH, false, "produce files for debugging purposes");
options.addOption(TIMEOUT, true, "maximum runtime in seconds (default 100)");
options.addOption(XML, false, "generate results in XML format");
return options;
}
public static JRealizabilitySettings parse(String[] args) {
JRealizabilityArgumentParser parser = new JRealizabilityArgumentParser();
parser.parseArguments(args);
return parser.settings;
}
@Override
protected void parseCommandLine(CommandLine line) {
super.parseCommandLine(line);
ensureExclusive(line, EXCEL, XML);
if (line.hasOption(EXCEL)) {
settings.excel = true;
}
if (line.hasOption(EXTEND_CEX)) {
settings.extendCounterexample = true;
}
if (line.hasOption(N)) {
settings.n = parseNonnegativeInt(line.getOptionValue(N));
}
if (line.hasOption(REDUCE)) {
settings.reduce = true;
}
if (line.hasOption(TIMEOUT)) {
settings.timeout = parseNonnegativeInt(line.getOptionValue(TIMEOUT));
}
if (line.hasOption(SCRATCH)) {
settings.scratch = true;
}
if (line.hasOption(XML)) {
settings.xml = true;
}
}
}
| 2,299
| 27.75
| 92
|
java
|
jkind
|
jkind-master/jkind/src/jkind/Settings.java
|
package jkind;
public class Settings {
public String filename = null;
}
| 74
| 11.5
| 31
|
java
|
jkind
|
jkind-master/jkind/src/jkind/JRealizabilitySettings.java
|
package jkind;
public class JRealizabilitySettings extends Settings {
public int n = 200;
public int timeout = 100;
public boolean excel = false;
public boolean xml = false;
public boolean extendCounterexample = false;
public boolean reduce = false;
public boolean scratch = false;
}
| 292
| 23.416667
| 54
|
java
|
jkind
|
jkind-master/jkind/src/jkind/JRealizability.java
|
package jkind;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import jkind.analysis.StaticAnalyzer;
import jkind.lustre.Node;
import jkind.lustre.Program;
import jkind.realizability.engines.RealizabilityDirector;
import jkind.translation.Specification;
import jkind.translation.Translate;
import jkind.util.Util;
public class JRealizability {
public static void main(String[] args) {
try {
JRealizabilitySettings settings = JRealizabilityArgumentParser.parse(args);
String filename = settings.filename;
Program program = Main.parseLustre(filename);
StaticAnalyzer.check(program, SolverOption.Z3, settings);
realizabilitySpecificChecks(program);
program = Translate.translate(program);
Specification spec = new Specification(program);
int exitCode = new RealizabilityDirector(settings, spec).run();
System.exit(exitCode); // Kills all threads
} catch (Throwable t) {
t.printStackTrace();
System.exit(ExitCodes.UNCAUGHT_EXCEPTION);
}
}
private static void realizabilitySpecificChecks(Program program) {
Node main = program.getMainNode();
boolean valid = true;
valid = valid && checkNoFunctions(program);
valid = valid && realizablitityQueryExists(main);
valid = valid && realizablitityInputsNodeInputs(main);
valid = valid && realizablitityInputsUnique(main);
if (!valid) {
System.exit(ExitCodes.STATIC_ANALYSIS_ERROR);
}
}
private static boolean checkNoFunctions(Program program) {
if (!program.functions.isEmpty()) {
StdErr.error("functions are not supported in JRealizability");
return false;
} else {
return true;
}
}
private static boolean realizablitityQueryExists(Node main) {
if (main.realizabilityInputs == null) {
StdErr.error("main node '" + main.id + "' must have realizability query");
return false;
} else {
return true;
}
}
private static boolean realizablitityInputsNodeInputs(Node main) {
boolean pass = true;
List<String> inputs = Util.getIds(main.inputs);
for (String ri : main.realizabilityInputs) {
if (!inputs.contains(ri)) {
StdErr.error("in node '" + main.id + "' realizability input '" + ri + "' must be a node input");
pass = false;
}
}
return pass;
}
private static boolean realizablitityInputsUnique(Node main) {
boolean unique = true;
Set<String> seen = new HashSet<>();
for (String ri : main.realizabilityInputs) {
if (!seen.add(ri)) {
StdErr.error("in node '" + main.id + "' realizability input '" + ri + "' listed multiple times");
unique = false;
}
}
return unique;
}
}
| 2,584
| 27.722222
| 101
|
java
|
jkind
|
jkind-master/jkind/src/jkind/StdErr.java
|
package jkind;
import java.util.List;
import jkind.analysis.Level;
import jkind.lustre.Location;
import jkind.util.Util;
public class StdErr {
private static List<String> locationReference;
public static void setLocationReference(List<String> locationReference) {
StdErr.locationReference = locationReference;
}
public static void warning(String text) {
output(Level.WARNING, text);
}
public static void warning(Location loc, String text) {
output(Level.WARNING, loc, text);
}
public static void error(String text) {
output(Level.ERROR, text);
}
public static void error(Location loc, String text) {
output(Level.ERROR, loc, text);
}
public static void fatal(int exitCode, String text) {
error(text);
System.exit(exitCode);
}
public static void fatal(int exitCode, Location loc, String text) {
error(loc, text);
System.exit(exitCode);
}
public static void output(Level level, String text) {
if (level != Level.IGNORE) {
println(level + " " + text);
}
}
public static void output(Level level, Location loc, String text) {
if (level != Level.IGNORE) {
println(level + " at line " + loc + " " + text);
if (level == Level.ERROR) {
showLocation(loc);
}
}
}
public static void showLocation(Location loc) {
if (1 <= loc.line && loc.line <= locationReference.size()) {
String line = locationReference.get(loc.line - 1);
StdErr.println(line);
StdErr.println(Util.spaces(loc.charPositionInLine) + "^");
}
}
public static void println(String text) {
System.err.println(text);
}
public static void printStackTrace(Throwable t) {
t.printStackTrace(System.err);
}
}
| 1,651
| 21.630137
| 74
|
java
|
jkind
|
jkind-master/jkind/src/jkind/JFaultSeederArgumentParser.java
|
package jkind;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.Options;
public class JFaultSeederArgumentParser extends ArgumentParser {
private static final String TOTAL_FAULTS = "total_faults";
private static final String SINGLE_FILE = "single_file";
private static final String STRATEGY = "strategy";
// private static final String QUIET = "quiet";
private static final String STATS = "stats";
private static final String NON_LINEAR = "non_linear";
private final JFaultSeederSettings settings;
private JFaultSeederArgumentParser() {
this("JKindFaultSeeder", new JFaultSeederSettings());
}
private JFaultSeederArgumentParser(String name, JFaultSeederSettings settings) {
super(name, settings);
this.settings = settings;
}
@Override
protected Options getOptions() {
Options options = super.getOptions();
options.addOption(TOTAL_FAULTS, true,
"total faults to emit per file (used with Proportional and Adjusted strategies)");
options.addOption(SINGLE_FILE, false, "add all faults to one file (default is one fault per file)");
options.addOption(STRATEGY, true, "strategy for fault construction. One of: {manual, proportional, adjusted}");
options.addOption(STATS, false, "provide statistics for the number of possible faults");
options.addOption(NON_LINEAR, false, "allow multiplication and division mutations between two variables.");
return options;
}
public static JFaultSeederSettings parse(String[] args) {
JFaultSeederArgumentParser parser = new JFaultSeederArgumentParser();
parser.parseArguments(args);
parser.checkSettings();
return parser.settings;
}
@Override
protected void parseCommandLine(CommandLine line) {
super.parseCommandLine(line);
if (line.hasOption(TOTAL_FAULTS)) {
settings.totalFaults = parseNonnegativeInt(line.getOptionValue(TOTAL_FAULTS));
}
if (line.hasOption(SINGLE_FILE)) {
settings.faultPerFile = true;
}
if (line.hasOption(STRATEGY)) {
switch (line.getOptionValue(STRATEGY).toLowerCase()) {
case "manual":
settings.strategy = JFaultSeederSettings.Strategy.Manual;
break;
case "adjusted":
settings.strategy = JFaultSeederSettings.Strategy.Adjusted;
break;
case "proportional":
settings.strategy = JFaultSeederSettings.Strategy.Proportional;
break;
default:
StdErr.fatal(ExitCodes.INVALID_OPTIONS, "Unknown strategy");
}
}
if (line.hasOption(STATS)) {
settings.stats = true;
}
}
private void checkSettings() {
if (settings.strategy == JFaultSeederSettings.Strategy.Manual) {
StdErr.fatal(ExitCodes.INVALID_OPTIONS, "Strategy manual is not yet supported.");
}
}
}
| 2,666
| 31.13253
| 114
|
java
|
jkind
|
jkind-master/jkind/src/jkind/JFaultSeeder.java
|
package jkind;
import java.io.File;
import java.io.IOException;
import java.util.Set;
import java.util.concurrent.ThreadLocalRandom;
import jkind.analysis.StaticAnalyzer;
import jkind.faultseeder.ComputeFaultSitesVisitor;
import jkind.faultseeder.FaultReplacementLocations;
import jkind.faultseeder.FaultSites;
import jkind.lustre.Node;
import jkind.lustre.Program;
import jkind.lustre.builders.ProgramBuilder;
import jkind.lustre.visitors.TypeReconstructor;
import jkind.slicing.DependencyMap;
import jkind.slicing.LustreSlicer;
import jkind.translation.RemoveEnumTypes;
import jkind.translation.Translate;
import jkind.util.Util;
public class JFaultSeeder {
/*
* TODO: MWW - this is currently a hack, but good enough to do what we want for
* the Jaroslav paper. It should be extended.
*/
/*
* private static void calcFaultRatios(JFaultSeederSettings settings, FaultSites fs) {
* int totalFaults = fs.totalFaults();
* double doubleTotalFaults = totalFaults;
* double arithPct = fs.arithmeticOp / doubleTotalFaults;
* double relationalPct = fs.relationalOp / doubleTotalFaults;
* double equalityPct = fs.equalityOp / doubleTotalFaults;
* double booleanPct = fs.booleanOp / doubleTotalFaults;
* double negationPct = fs.negationOp / doubleTotalFaults;
* double delayPct = fs.delayOp / doubleTotalFaults;
* double constantPct = fs.constantOp / doubleTotalFaults;
* double nodeCallPct = fs.nodeCallParameter / doubleTotalFaults;
* double variableReplacementPct = fs.variableReplacement / doubleTotalFaults;
* }
*/
private final JFaultSeederSettings settings;
public JFaultSeeder(String[] args) {
settings = JFaultSeederArgumentParser.parse(args);
String filename = settings.filename;
if (!filename.toLowerCase().endsWith(".lus")) {
StdErr.error("input file must have .lus extension");
}
}
public void execute() throws Throwable {
if (settings.directory != null) {
File theDir = new File(settings.directory);
if (!theDir.exists()) {
theDir.mkdir();
}
}
Program program = Main.parseLustre(settings.filename);
StaticAnalyzer.check(program, SolverOption.Z3, settings);
program = Translate.translate(program);
program = RemoveEnumTypes.program(program);
Node main = program.getMainNode();
DependencyMap dependencyMap = new DependencyMap(main, main.properties, program.functions);
main = LustreSlicer.slice(main, dependencyMap);
// Create the new program & get types of elements.
Program transformed = new ProgramBuilder(program).clearNodes().addNode(main).build();
TypeReconstructor typeReconstructor = new TypeReconstructor(transformed);
// Find fault sites.
ComputeFaultSitesVisitor visitor = new ComputeFaultSitesVisitor(typeReconstructor, settings.linearOnly,
new FaultReplacementLocations());
transformed.accept(visitor);
FaultSites fs = visitor.getFaultSites();
// Emit faulty programs.
String fileRoot = settings.filename.substring(0, settings.filename.length() - 4);
FaultReplacementLocations locs = createFaultReplacementLocations(fs);
createMutantFiles(typeReconstructor, fileRoot, transformed, locs);
}
private int faultInRange(int max) {
return ThreadLocalRandom.current().nextInt(0, max + 1);
}
private void populateFaults(int faultsToAdd, int max, Set<Integer> elements) {
if (faultsToAdd > max) {
throw new IllegalArgumentException("More desired faults than fault locations.");
}
while (faultsToAdd > 0) {
int newFaultLocation = faultInRange(max);
if (!elements.contains(newFaultLocation)) {
elements.add(newFaultLocation);
faultsToAdd--;
}
}
}
private FaultReplacementLocations createFaultReplacementLocations(FaultSites fs) {
int desiredFaults = settings.totalFaults;
int arithmeticFaults = Integer.min(desiredFaults / 4, fs.arithmeticOp);
int relationalFaults = Integer.min(desiredFaults / 4, fs.relationalOp);
int booleanFaults = Integer.min(desiredFaults / 4, fs.booleanOp);
int constantFaults = Integer.min(desiredFaults / 8, fs.constantOp);
int equalityFaults = Integer.min(desiredFaults / 8, fs.equalityOp);
FaultReplacementLocations locations = new FaultReplacementLocations();
populateFaults(arithmeticFaults, fs.arithmeticOp, locations.arithmeticOp);
populateFaults(relationalFaults, fs.relationalOp, locations.relationalOp);
populateFaults(booleanFaults, fs.booleanOp, locations.booleanOp);
populateFaults(constantFaults, fs.constantOp, locations.constantOp);
populateFaults(equalityFaults, fs.equalityOp, locations.equalityOp);
System.out.println(locations.toString());
return locations;
}
private void createMutantFile(TypeReconstructor typeReconstructor, String fileName, Program program,
FaultReplacementLocations locations) throws IOException {
ComputeFaultSitesVisitor visitor = new ComputeFaultSitesVisitor(typeReconstructor, settings.linearOnly,
locations);
program = visitor.visit(program);
Util.writeToFile(program.toString(), new File(fileName));
System.out.println("Wrote " + fileName);
}
interface ConstructFaultReplacementLocation {
FaultReplacementLocations operation(int location);
}
public void emitSingleFaultPrograms(TypeReconstructor typeReconstructor, String fileNameRoot, Program program,
Set<Integer> locations, ConstructFaultReplacementLocation locLambda) throws IOException {
int index = 0;
for (Integer elem : locations) {
createMutantFile(typeReconstructor, fileNameRoot + index + ".lus", program, locLambda.operation(elem));
index++;
}
}
/*
* public int arithmeticOp = 0;
* public int incrementOp = 0;
* public int relationalOp = 0;
* public int equalityOp = 0;
* public int booleanOp = 0;
* public int negationOp = 0;
* public int delayOp = 0;
* public int constantOp = 0;
* public int nodeCallParameter = 0;
* public int variableReplacement = 0;
*/
public void createMutantFiles(TypeReconstructor typeReconstructor, String fileNameRoot, Program program,
FaultReplacementLocations locations) throws IOException {
if (settings.faultPerFile) {
emitSingleFaultPrograms(typeReconstructor, fileNameRoot + ".arithmeticFault", program,
locations.arithmeticOp, loc -> {
FaultReplacementLocations locs = new FaultReplacementLocations();
locs.arithmeticOp.add(loc);
return locs;
});
emitSingleFaultPrograms(typeReconstructor, fileNameRoot + ".incrementFault", program, locations.incrementOp,
loc -> {
FaultReplacementLocations locs = new FaultReplacementLocations();
locs.incrementOp.add(loc);
return locs;
});
emitSingleFaultPrograms(typeReconstructor, fileNameRoot + ".relationalFault", program,
locations.relationalOp, loc -> {
FaultReplacementLocations locs = new FaultReplacementLocations();
locs.relationalOp.add(loc);
return locs;
});
emitSingleFaultPrograms(typeReconstructor, fileNameRoot + ".equalityFault", program, locations.equalityOp,
loc -> {
FaultReplacementLocations locs = new FaultReplacementLocations();
locs.equalityOp.add(loc);
return locs;
});
emitSingleFaultPrograms(typeReconstructor, fileNameRoot + ".booleanFault", program, locations.booleanOp,
loc -> {
FaultReplacementLocations locs = new FaultReplacementLocations();
locs.booleanOp.add(loc);
return locs;
});
emitSingleFaultPrograms(typeReconstructor, fileNameRoot + ".negationFault", program, locations.negationOp,
loc -> {
FaultReplacementLocations locs = new FaultReplacementLocations();
locs.negationOp.add(loc);
return locs;
});
emitSingleFaultPrograms(typeReconstructor, fileNameRoot + ".delayFault", program, locations.delayOp,
loc -> {
FaultReplacementLocations locs = new FaultReplacementLocations();
locs.delayOp.add(loc);
return locs;
});
emitSingleFaultPrograms(typeReconstructor, fileNameRoot + ".constantFault", program, locations.constantOp,
loc -> {
FaultReplacementLocations locs = new FaultReplacementLocations();
locs.constantOp.add(loc);
return locs;
});
emitSingleFaultPrograms(typeReconstructor, fileNameRoot + ".nodeCallParameterFault", program,
locations.nodeCallParameter, loc -> {
FaultReplacementLocations locs = new FaultReplacementLocations();
locs.nodeCallParameter.add(loc);
return locs;
});
emitSingleFaultPrograms(typeReconstructor, fileNameRoot + ".variableReplacementFault", program,
locations.variableReplacement, loc -> {
FaultReplacementLocations locs = new FaultReplacementLocations();
locs.variableReplacement.add(loc);
return locs;
});
} else {
createMutantFile(typeReconstructor, fileNameRoot + ".allFaults.lus", program, locations);
}
}
public static void main(String[] args) {
try {
JFaultSeeder faultSeeder = new JFaultSeeder(args);
faultSeeder.execute();
} catch (Throwable t) {
t.printStackTrace();
System.exit(ExitCodes.UNCAUGHT_EXCEPTION);
}
}
}
| 9,030
| 34.695652
| 111
|
java
|
jkind
|
jkind-master/jkind/src/jkind/JLustre2Excel.java
|
package jkind;
import java.util.Set;
import java.util.TreeSet;
import jkind.analysis.StaticAnalyzer;
import jkind.lustre.EnumType;
import jkind.lustre.Program;
import jkind.translation.Node2Excel;
import jkind.translation.Translate;
import jkind.util.Util;
public class JLustre2Excel {
public static void main(String args[]) {
try {
if (args.length != 1) {
StdErr.fatal(ExitCodes.INVALID_OPTIONS, "usage: jlustre2excel <input>");
}
String filename = args[0];
Program program = Main.parseLustre(filename);
StaticAnalyzer.check(program, SolverOption.Z3);
ensureUniqueEnumValues(program);
ensureNoFunctions(program);
program = Translate.translate(program);
String outFilename = filename + ".xls";
new Node2Excel().convert(program.getMainNode(), outFilename);
System.out.println("Wrote " + outFilename);
} catch (Exception e) {
e.printStackTrace();
System.exit(ExitCodes.UNCAUGHT_EXCEPTION);
}
}
private static void ensureUniqueEnumValues(Program program) {
for (EnumType et : Util.getEnumTypes(program.types)) {
Set<String> seen = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
for (String value : et.values) {
if (seen.contains(value)) {
StdErr.fatal(ExitCodes.UNSUPPORTED_FEATURE, et.location,
"cannot handle enumerated values that differ only by case");
} else {
seen.add(value);
}
}
}
}
private static void ensureNoFunctions(Program program) {
if (!program.functions.isEmpty()) {
StdErr.fatal(ExitCodes.UNSUPPORTED_FEATURE, "functions are not supported");
}
}
}
| 1,573
| 27.107143
| 78
|
java
|
jkind
|
jkind-master/jkind/src/jkind/ExitCodes.java
|
package jkind;
public class ExitCodes {
public static final int UNKNOWN_ENTRY_POINT = -1;
public static final int INVALID_OPTIONS = -2;
public static final int FILE_NOT_FOUND = -3;
public static final int FILE_NOT_READABLE = -4;
public static final int PARSE_ERROR = -5;
public static final int STATIC_ANALYSIS_ERROR = -6;
public static final int UNSUPPORTED_FEATURE = -7;
public static final int UNCAUGHT_EXCEPTION = -8;
public static final int IVC_EXCEPTION = -9;
}
| 478
| 33.214286
| 52
|
java
|
jkind
|
jkind-master/jkind/src/jkind/JKindArgumentParser.java
|
package jkind;
import static java.util.stream.Collectors.joining;
import java.util.Arrays;
import java.util.List;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.Options;
import jkind.engines.SolverUtil;
public class JKindArgumentParser extends ArgumentParser {
private static final String EXCEL = "excel";
private static final String INDUCT_CEX = "induct_cex";
private static final String MAIN = "main";
private static final String N = "n";
private static final String NO_BMC = "no_bmc";
private static final String NO_INV_GEN = "no_inv_gen";
private static final String NO_K_INDUCTION = "no_k_induction";
private static final String PDR_MAX = "pdr_max";
private static final String READ_ADVICE = "read_advice";
private static final String IVC = "ivc";
private static final String IVC_ALL = "all_ivcs";
private static final String NO_SLICING = "no_slicing";
private static final String SCRATCH = "scratch";
private static final String SMOOTH = "smooth";
private static final String SOLVER = "solver";
private static final String TIMEOUT = "timeout";
private static final String WRITE_ADVICE = "write_advice";
private static final String XML = "xml";
private static final String XML_TO_STDOUT = "xml_to_stdout";
private final JKindSettings settings;
private JKindArgumentParser() {
this("JKind", new JKindSettings());
}
private JKindArgumentParser(String name, JKindSettings settings) {
super(name, settings);
this.settings = settings;
}
@Override
protected Options getOptions() {
Options options = super.getOptions();
options.addOption(EXCEL, false, "generate results in Excel format");
options.addOption(INDUCT_CEX, false, "generate inductive counterexamples");
options.addOption(IVC, false,
"find an inductive validity core for valid properties (based on --%IVC annotated elements)");
options.addOption(IVC_ALL, false,
"find all inductive validity cores for valid properties (based on --%IVC annotated elements)");
options.addOption(MAIN, true, "specify main node (overrides --%MAIN)");
options.addOption(N, true, "maximum depth for bmc and k-induction (default: unbounded)");
options.addOption(NO_BMC, false, "disable bounded model checking");
options.addOption(NO_INV_GEN, false, "disable invariant generation");
options.addOption(NO_K_INDUCTION, false, "disable k-induction");
options.addOption(NO_SLICING, false, "disable slicing");
options.addOption(PDR_MAX, true, "maximum number of PDR parallel instances (0 to disable PDR)");
options.addOption(READ_ADVICE, true, "read advice from specified file");
options.addOption(SCRATCH, false, "produce files for debugging purposes");
options.addOption(SMOOTH, false, "smooth counterexamples (minimal changes in input values)");
options.addOption(SOLVER, true,
"SMT solver (default: smtinterpol, alternatives: z3, yices, yices2, cvc4, mathsat)");
options.addOption(TIMEOUT, true, "maximum runtime in seconds (default: unbounded)");
options.addOption(WRITE_ADVICE, true, "write advice to specified file");
options.addOption(XML, false, "generate results in XML format");
options.addOption(XML_TO_STDOUT, false, "generate results in XML format on stardard out");
return options;
}
public static JKindSettings parse(String[] args) {
JKindArgumentParser parser = new JKindArgumentParser();
parser.parseArguments(args);
parser.checkSettings();
return parser.settings;
}
@Override
protected void parseCommandLine(CommandLine line) {
if (line.hasOption(VERSION)) {
StdErr.println(name + " " + Main.getVersion());
printDectectedSolvers();
System.exit(0);
}
super.parseCommandLine(line);
ensureExclusive(line, EXCEL, XML);
ensureExclusive(line, EXCEL, XML_TO_STDOUT);
ensureExclusive(line, XML, XML_TO_STDOUT);
if (line.hasOption(EXCEL)) {
settings.excel = true;
}
if (line.hasOption(INDUCT_CEX)) {
settings.inductiveCounterexamples = true;
}
if (line.hasOption(MAIN)) {
settings.main = line.getOptionValue(MAIN);
}
if (line.hasOption(NO_BMC)) {
settings.boundedModelChecking = false;
}
if (line.hasOption(NO_INV_GEN)) {
settings.invariantGeneration = false;
}
if (line.hasOption(NO_K_INDUCTION)) {
settings.kInduction = false;
}
if (line.hasOption(NO_SLICING)) {
settings.slicing = false;
/**
* Inlining without slicing away the inlined equations creates
* problems for reconstruction
*/
settings.inlining = false;
}
if (line.hasOption(N)) {
settings.n = parseNonnegativeInt(line.getOptionValue(N));
}
if (line.hasOption(PDR_MAX)) {
settings.pdrMax = parseNonnegativeInt(line.getOptionValue(PDR_MAX));
} else {
int available = Runtime.getRuntime().availableProcessors();
int heuristic = (available - 4) / 2;
settings.pdrMax = Math.max(1, heuristic);
}
if (line.hasOption(READ_ADVICE)) {
settings.readAdvice = line.getOptionValue(READ_ADVICE);
}
if (line.hasOption(IVC)) {
settings.reduceIvc = true;
}
if (line.hasOption(IVC_ALL)) {
settings.reduceIvc = true;
settings.allIvcs = true;
}
if (line.hasOption(TIMEOUT)) {
settings.timeout = parseNonnegativeInt(line.getOptionValue(TIMEOUT));
settings.allIvcsJkindTimeout = settings.timeout;
}
if (line.hasOption(SCRATCH)) {
settings.scratch = true;
}
if (line.hasOption(SMOOTH)) {
settings.smoothCounterexamples = true;
}
if (line.hasOption(SOLVER)) {
settings.solver = getSolverOption(line.getOptionValue(SOLVER));
}
if (line.hasOption(WRITE_ADVICE)) {
settings.writeAdvice = line.getOptionValue(WRITE_ADVICE);
}
if (line.hasOption(XML)) {
settings.xml = true;
}
if (line.hasOption(XML_TO_STDOUT)) {
settings.xmlToStdout = true;
settings.xml = true;
}
}
private static SolverOption getSolverOption(String solver) {
List<SolverOption> options = Arrays.asList(SolverOption.values());
for (SolverOption option : options) {
if (solver.equals(option.toString())) {
return option;
}
}
StdErr.error("unknown solver: " + solver);
StdErr.println("Valid options: " + options);
System.exit(ExitCodes.INVALID_OPTIONS);
return null;
}
private void checkSettings() {
if (settings.reduceIvc) {
if (settings.solver == SolverOption.CVC4) {
StdErr.warning(settings.solver + " does not support unsat-cores so IVC reduction will be slow");
}
}
if (settings.allIvcs) {
StdErr.warning("IVC reduction requires at least Z3 4.5");
if (settings.solver == SolverOption.CVC4 || settings.solver == SolverOption.YICES2) {
StdErr.warning(settings.solver + " does not support unsat-cores so IVC reduction will be slow");
}
}
if (settings.smoothCounterexamples) {
if (settings.solver != SolverOption.YICES && settings.solver != SolverOption.Z3) {
StdErr.fatal(ExitCodes.INVALID_OPTIONS, "smoothing not supported with " + settings.solver);
}
}
if (!settings.boundedModelChecking && !settings.kInduction && !settings.invariantGeneration
&& settings.pdrMax == 0 && settings.readAdvice == null) {
StdErr.fatal(ExitCodes.INVALID_OPTIONS, "all proving engines disabled");
}
if (!settings.boundedModelChecking && settings.kInduction) {
StdErr.warning("k-induction requires bmc");
}
}
private void printDectectedSolvers() {
String detected = SolverUtil.availableSolvers().stream().map(Object::toString).collect(joining(", "));
StdErr.println("Detected solvers: " + detected);
}
}
| 7,484
| 30.851064
| 104
|
java
|
jkind
|
jkind-master/jkind/src/jkind/JLustre2KindArgumentParser.java
|
package jkind;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.Options;
public class JLustre2KindArgumentParser extends ArgumentParser {
private static final String ENCODE = "encode";
private static final String OBFUSCATE = "obfuscate";
private static final String STDOUT = "stdout";
private final JLustre2KindSettings settings;
private JLustre2KindArgumentParser() {
this("JLustre2Kind", new JLustre2KindSettings());
}
private JLustre2KindArgumentParser(String name, JLustre2KindSettings settings) {
super(name, settings);
this.settings = settings;
}
@Override
protected Options getOptions() {
Options options = super.getOptions();
options.addOption(STDOUT, false, "write result to standard out");
options.addOption(OBFUSCATE, false, "obfuscate variable names");
options.addOption(ENCODE, false, "encode identifiers to avoid reserved symbols");
return options;
}
public static JLustre2KindSettings parse(String[] args) {
JLustre2KindArgumentParser parser = new JLustre2KindArgumentParser();
parser.parseArguments(args);
return parser.settings;
}
@Override
protected void parseCommandLine(CommandLine line) {
super.parseCommandLine(line);
if (line.hasOption(ENCODE)) {
settings.encode = true;
}
if (line.hasOption(OBFUSCATE)) {
settings.obfuscate = true;
}
if (line.hasOption(STDOUT)) {
settings.stdout = true;
}
}
}
| 1,414
| 25.203704
| 83
|
java
|
jkind
|
jkind-master/jkind/src/jkind/ArgumentParser.java
|
package jkind;
import java.math.BigInteger;
import org.apache.commons.cli.BasicParser;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.Options;
public abstract class ArgumentParser {
protected static final String VERSION = "version";
protected static final String HELP = "help";
protected final String name;
protected final Settings baseSettings;
protected ArgumentParser(String name, Settings baseSettings) {
super();
this.name = name;
this.baseSettings = baseSettings;
}
public void parseArguments(String[] args) {
CommandLineParser parser = new BasicParser();
try {
parseCommandLine(parser.parse(getOptions(), args));
} catch (Throwable t) {
StdErr.fatal(ExitCodes.INVALID_OPTIONS, "reading command line arguments: " + t.getMessage());
}
}
protected Options getOptions() {
Options options = new Options();
options.addOption(VERSION, false, "display version information");
options.addOption(HELP, false, "print this message");
return options;
}
protected void parseCommandLine(CommandLine line) {
if (line.hasOption(VERSION)) {
StdErr.println(name + " " + Main.getVersion());
System.exit(0);
}
if (line.hasOption(HELP)) {
printHelp();
System.exit(0);
}
String[] input = line.getArgs();
if (input.length != 1) {
printHelp();
System.exit(ExitCodes.INVALID_OPTIONS);
}
baseSettings.filename = input[0];
}
protected void printHelp() {
HelpFormatter formatter = new HelpFormatter();
formatter.printHelp(name.toLowerCase() + " [options] <input>", getOptions());
}
protected static int parseNonnegativeInt(String text) {
BigInteger bi = new BigInteger(text);
if (bi.compareTo(BigInteger.ZERO) < 0) {
return 0;
} else if (bi.compareTo(BigInteger.valueOf(Integer.MAX_VALUE)) > 0) {
return Integer.MAX_VALUE;
} else {
return bi.intValue();
}
}
protected static void ensureExclusive(CommandLine line, String opt1, String opt2) {
if (line.hasOption(opt1) && line.hasOption(opt2)) {
StdErr.fatal(ExitCodes.INVALID_OPTIONS, "cannot use option -" + opt1 + " with option -" + opt2);
}
}
}
| 2,217
| 26.382716
| 99
|
java
|
jkind
|
jkind-master/jkind/src/jkind/JKindSettings.java
|
package jkind;
public class JKindSettings extends Settings {
public int n = Integer.MAX_VALUE;
public int timeout = Integer.MAX_VALUE;
public boolean miniJkind = false;
public boolean excel = false;
public boolean xml = false;
public boolean xmlToStdout = false;
public String main = null;
public boolean boundedModelChecking = true;
public boolean kInduction = true;
public boolean invariantGeneration = true;
public int pdrMax = 1;
public boolean inductiveCounterexamples = false;
public boolean reduceIvc = false;
public boolean allIvcs = false;
public boolean smoothCounterexamples = false;
public AllIvcsAlgorithm allIvcsAlgorithm = AllIvcsAlgorithm.OFFLINE_MIVC_ENUM_ALG;
public int allIvcsMaxGrows = 1000;
public int allIvcsJkindTimeout = -1; // if set to -1, a timeout will be computed based on the first call of the jkind's solve method
public boolean inlining = true;
public boolean slicing = true;
public SolverOption solver = SolverOption.SMTINTERPOL;
public boolean scratch = false;
public String writeAdvice = null;
public String readAdvice = null;
public boolean allAssigned = false;
public JKindSettings() {
}
}
| 1,159
| 32.142857
| 133
|
java
|
jkind
|
jkind-master/jkind/src/jkind/JFaultSeederSettings.java
|
package jkind;
/*
* Fault types to consider:
* Arithmetic operator faults
* Relational operator faults
* Boolean operator faults
* Negation faults
* Delay faults
* Constant faults (+1 / -1)
* Node call parameter faults (misrouting parameters)
* Variable replacement faults
*
*
*/
public class JFaultSeederSettings extends Settings {
public int totalFaults = 10;
public boolean faultPerFile = true;
/*
* The types are:
* Proportional: # of faults generated is proportional to the number of possible faults
* Adjusted: reduce the number of variable replacement and delay faults, which can happen
* at any expression.
* Manual: generate mutants based on user input
*/
public enum Strategy {
Proportional, Adjusted, Manual
};
public Strategy strategy = Strategy.Adjusted;
// If true does not write information to stdout.
public boolean quiet = false;
public String directory = null;
// emit statistics about the total number of mutants
public boolean stats = true;
// slice model so that mutants are only found in relevant parts of model.
public boolean slice = true;
// only create linear mutants
public boolean linearOnly = true;
}
| 1,201
| 24.574468
| 90
|
java
|
jkind
|
jkind-master/jkind/src/jkind/lustre/parsing/StdErrErrorListener.java
|
package jkind.lustre.parsing;
import jkind.StdErr;
import jkind.lustre.Location;
import org.antlr.v4.runtime.BaseErrorListener;
import org.antlr.v4.runtime.RecognitionException;
import org.antlr.v4.runtime.Recognizer;
public class StdErrErrorListener extends BaseErrorListener {
@Override
public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol, int line, int charPositionInLine,
String msg, RecognitionException e) {
StdErr.println("Parse error line " + line + ":" + charPositionInLine + " " + msg);
StdErr.showLocation(new Location(line, charPositionInLine));
}
}
| 599
| 32.333333
| 111
|
java
|
jkind
|
jkind-master/jkind/src/jkind/lustre/parsing/FlattenIds.java
|
package jkind.lustre.parsing;
import jkind.lustre.ArrayAccessExpr;
import jkind.lustre.Expr;
import jkind.lustre.IdExpr;
import jkind.lustre.RecordAccessExpr;
import jkind.lustre.visitors.AstMapVisitor;
public class FlattenIds extends AstMapVisitor {
@Override
public Expr visit(ArrayAccessExpr e) {
return new IdExpr(e.location, e.toString());
}
@Override
public Expr visit(RecordAccessExpr e) {
return new IdExpr(e.location, e.toString());
}
}
| 459
| 22
| 47
|
java
|
jkind
|
jkind-master/jkind/src/jkind/lustre/parsing/ValidIdChecker.java
|
package jkind.lustre.parsing;
import jkind.StdErr;
import jkind.lustre.Equation;
import jkind.lustre.IdExpr;
import jkind.lustre.Location;
import jkind.lustre.Program;
import jkind.lustre.VarDecl;
import jkind.lustre.visitors.AstIterVisitor;
public class ValidIdChecker extends AstIterVisitor {
private boolean passed = true;
public static boolean check(Program program) {
ValidIdChecker checker = new ValidIdChecker();
checker.visit(program);
return checker.passed;
}
@Override
public Void visit(VarDecl e) {
super.visit(e);
check(e.location, e.id);
return null;
}
@Override
public Void visit(IdExpr e) {
super.visit(e);
check(e.location, e.id);
return null;
}
@Override
public Void visit(Equation e) {
super.visit(e);
e.lhs.forEach(this::visit);
return null;
}
private void check(Location location, String id) {
if (id.contains("~") || id.contains("[") || id.contains("]") || id.contains(".")) {
StdErr.error(location, "Invalid id: " + id);
passed = false;
}
}
}
| 1,020
| 20.270833
| 85
|
java
|
jkind
|
jkind-master/jkind/src/jkind/writers/Writer.java
|
package jkind.writers;
import java.util.List;
import java.util.Map;
import java.util.Set;
import jkind.engines.ivcs.AllIVCs;
import jkind.lustre.Expr;
import jkind.results.Counterexample;
public abstract class Writer {
public abstract void begin();
public abstract void end();
public abstract void writeInvalid(String prop, String source, Counterexample cex, List<String> conflicts,
double runtime);
public abstract void writeUnknown(List<String> props, int trueFor,
Map<String, Counterexample> inductiveCounterexamples, double runtime);
public abstract void writeBaseStep(List<String> props, int k);
// Used only by JRealiability
public abstract void writeInconsistent(String prop, String source, int k, double runtime);
public abstract void writeValid(List<String> props, String source, int k, double proofTime, double runtime,
List<Expr> invariants, Set<String> ivc, List<AllIVCs> allIvcs,
boolean mivcTimedOut);
}
| 947
| 29.580645
| 108
|
java
|
jkind
|
jkind-master/jkind/src/jkind/writers/ExcelWriter.java
|
package jkind.writers;
import static java.util.stream.Collectors.toList;
import java.io.File;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import jkind.engines.ivcs.AllIVCs;
import jkind.excel.ExcelFormatter;
import jkind.lustre.Expr;
import jkind.lustre.Node;
import jkind.results.Counterexample;
import jkind.results.InconsistentProperty;
import jkind.results.InvalidProperty;
import jkind.results.Property;
import jkind.results.UnknownProperty;
import jkind.results.ValidProperty;
import jkind.results.layout.Layout;
import jkind.results.layout.NodeLayout;
public class ExcelWriter extends Writer {
private final File file;
private final Layout layout;
private final List<Property> properties = new ArrayList<>();
private ExcelFormatter formatter;
public ExcelWriter(String filename, Node node) {
this.file = new File(filename);
this.layout = new NodeLayout(node);
}
public ExcelWriter(String filename, Layout layout) {
this.file = new File(filename);
this.layout = layout;
}
@Override
public void begin() {
formatter = new ExcelFormatter(file, layout);
}
@Override
public void end() {
formatter.write(properties);
formatter.close();
}
private String escape(String invariant) {
return invariant.replace("<", "<").replace(">", ">");
}
@Override
public void writeValid(List<String> props, String source, int k, double proofTime, double runtime,
List<Expr> invariants, Set<String> ivc, List<AllIVCs> allIvcs,
boolean mivcTimedOut) {
List<String> invText = invariants.stream().map(Expr::toString).collect(toList());
// doesn't write allIvcs...
for (String prop : props) {
Set<List<String>> invariantSets = new HashSet<List<String>>();
Set<List<String>> ivcSets = new HashSet<List<String>>();
// The following are similar from the process in XmlWriter
if (!allIvcs.isEmpty()) {
for (AllIVCs ivcSet : allIvcs) {
List<String> curInvariant = new ArrayList<String>();
List<String> curIvc = new ArrayList<String>();
for (String invariant : ivcSet.getAllIVCList()) {
curInvariant.add(escape(invariant));
}
for (String supp : ivcSet.getAllIVCSet()) {
curIvc.add(supp);
}
invariantSets.add(curInvariant);
ivcSets.add(curIvc);
}
}
properties.add(
new ValidProperty(prop, source, k, runtime, invText, ivc, invariantSets, ivcSets, mivcTimedOut));
}
}
@Override
public void writeInvalid(String prop, String source, Counterexample cex, List<String> conflicts, double runtime) {
properties.add(new InvalidProperty(prop, source, cex, conflicts, runtime));
}
@Override
public void writeUnknown(List<String> props, int trueFor, Map<String, Counterexample> inductiveCounterexamples,
double runtime) {
for (String prop : props) {
properties.add(new UnknownProperty(prop, trueFor, inductiveCounterexamples.get(prop), runtime));
}
}
@Override
public void writeBaseStep(List<String> props, int k) {
}
@Override
public void writeInconsistent(String prop, String source, int k, double runtime) {
properties.add(new InconsistentProperty(prop, source, k, runtime));
}
}
| 3,196
| 28.878505
| 115
|
java
|
jkind
|
jkind-master/jkind/src/jkind/writers/ConsoleWriter.java
|
package jkind.writers;
import static java.util.stream.Collectors.toList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import jkind.engines.MiniJKind;
import jkind.engines.ivcs.AllIVCs;
import jkind.engines.messages.ValidMessage;
import jkind.lustre.Expr;
import jkind.results.Counterexample;
import jkind.results.layout.Layout;
import jkind.util.Util;
public class ConsoleWriter extends Writer {
private final Layout layout;
private MiniJKind miniJkind;
public ConsoleWriter(Layout layout) {
super();
this.layout = layout;
}
public ConsoleWriter(Layout layout, MiniJKind miniJkind) {
this(layout);
this.miniJkind = miniJkind;
}
@Override
public void begin() {
}
@Override
public void end() {
}
private void writeLine() {
System.out.println("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
}
@Override
public void writeValid(List<String> props, String source, int k, double proofTime, double runtime,
List<Expr> invariants, Set<String> ivc, List<AllIVCs> allIvcs,
boolean mivcTimedOut) {
if (miniJkind != null) {
miniJkind.setRuntime(runtime);
miniJkind.setValidMessage(
new ValidMessage(source, props.get(0), k, proofTime, invariants, ivc, null, null, mivcTimedOut));
} else {
writeLine();
System.out.println("VALID PROPERTIES: " + props + " || " + source + " || K = " + k + " || Time = "
+ Util.secondsToTime(runtime));
if (!invariants.isEmpty()) {
System.out.println("INVARIANTS:");
List<String> stringInvariants = invariants.stream().map(Object::toString).collect(toList());
for (String invariant : Util.safeStringSortedSet(stringInvariants)) {
System.out.println(" " + invariant);
}
}
if (!allIvcs.isEmpty()) {
int counter = 1;
System.out.println("\nINDUCTIVE VALIDITY CORES:\n");
if (!ivc.isEmpty()) {
if (ivc.contains("::AIVCtimedoutLoop::")) {
ivc.remove("::AIVCtimedoutLoop::");
System.out.println("...................................................................");
System.out.println(
"A timeout occured during checking a property. Thus, the produced MIVCs might not be minimal.");
System.out.println("...................................................................");
}
System.out.println("MUST ELEMENTS FOR THE PROPERTY:");
for (String e : Util.safeStringSortedSet(ivc)) {
System.out.println(" " + e);
}
}
System.out.println("\n" + allIvcs.size() + " INDUCTIVE VALIDITY CORES WERE FOUND:");
System.out.println("============================");
for (AllIVCs t : allIvcs) {
System.out.println("IVC #" + counter + ":");
counter++;
System.out.println("INVARIANTS:");
for (String inv : t.getAllIVCList()) {
System.out.println(" " + inv);
}
System.out.println("INDUCTIVE VALIDITY CORE:");
for (String core : t.getAllIVCSet()) {
System.out.println(" " + core);
}
System.out.println("============================");
}
} else if (!ivc.isEmpty()) {
System.out.println("INDUCTIVE VALIDITY CORE:");
for (String e : Util.safeStringSortedSet(ivc)) {
System.out.println(" " + e);
}
}
writeLine();
System.out.println();
}
}
@Override
public void writeInvalid(String prop, String source, Counterexample cex, List<String> conflicts, double runtime) {
if (miniJkind != null) {
miniJkind.setRuntime(runtime);
miniJkind.setInvalid(cex);
} else {
writeLine();
System.out.println("INVALID PROPERTY: " + prop + " || " + source + " || K = " + cex.getLength()
+ " || Time = " + Util.secondsToTime(runtime));
System.out.println(cex.toString(layout));
writeLine();
System.out.println();
}
}
@Override
public void writeUnknown(List<String> props, int trueFor, Map<String, Counterexample> inductiveCounterexamples,
double runtime) {
if (miniJkind != null) {
miniJkind.setRuntime(runtime);
miniJkind.setUnknown();
} else {
writeLine();
System.out.println("UNKNOWN PROPERTIES: " + props + " || True for " + trueFor + " steps" + " || Time = "
+ Util.secondsToTime(runtime));
writeLine();
System.out.println();
for (String prop : props) {
Counterexample cex = inductiveCounterexamples.get(prop);
if (cex != null) {
writeLine();
System.out.println("INDUCTIVE COUNTEREXAMPLE: " + prop + " || K = " + cex.getLength());
System.out.println(cex.toString(layout));
writeLine();
System.out.println();
}
}
}
}
@Override
public void writeBaseStep(List<String> props, int k) {
}
@Override
public void writeInconsistent(String prop, String source, int k, double runtime) {
throw new UnsupportedOperationException();
}
}
| 4,756
| 29.88961
| 115
|
java
|
jkind
|
jkind-master/jkind/src/jkind/writers/XmlWriter.java
|
package jkind.writers;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.List;
import java.util.Map;
import java.util.Set;
import jkind.engines.ivcs.AllIVCs;
import jkind.lustre.Expr;
import jkind.lustre.Type;
import jkind.lustre.VarDecl;
import jkind.lustre.values.BooleanValue;
import jkind.lustre.values.Value;
import jkind.results.Counterexample;
import jkind.results.FunctionTable;
import jkind.results.FunctionTableRow;
import jkind.results.Signal;
public class XmlWriter extends Writer {
private final PrintWriter out;
private final Map<String, Type> types;
public XmlWriter(String filename, Map<String, Type> types, boolean useStdout) throws FileNotFoundException {
if (useStdout) {
this.out = new PrintWriter(System.out, true);
} else {
this.out = new PrintWriter(new FileOutputStream(filename));
}
this.types = types;
}
@Override
public void begin() {
out.println("<?xml version=\"1.0\"?>");
out.println("<Results xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">");
}
@Override
public void end() {
out.println("</Results>");
out.close();
}
@Override
public void writeValid(List<String> props, String source, int k, double proofTime, double runtime,
List<Expr> invariants, Set<String> ivc, List<AllIVCs> allIvcs,
boolean mivcTimedOut) {
for (String prop : props) {
writeValid(prop, source, k, runtime, invariants, ivc, allIvcs);
}
}
public void writeValid(String prop, String source, int k, double runtime, List<Expr> invariants, Set<String> ivc,
List<AllIVCs> allIvcs) {
out.println(" <Property name=\"" + prop + "\">");
out.println(" <Runtime unit=\"sec\">" + runtime + "</Runtime>");
out.println(" <Answer source=\"" + source + "\">valid</Answer>");
out.println(" <K>" + k + "</K>");
if (allIvcs.isEmpty()) {
for (Expr invariant : invariants) {
out.println(" <Invariant>" + escape(invariant) + "</Invariant>");
}
for (String supp : ivc) {
out.println(" <Ivc>" + supp + "</Ivc>");
}
} else {
out.println(" <NumberOfIVCs>" + allIvcs.size() + "</NumberOfIVCs>");
int count = 1;
// In the all ivc elements, if any of the inner loops times out, the timeout information is encoded in
// the ivc field of the ValidMessage object
if (ivc.contains("::AIVCtimedoutLoop::")) {
ivc.remove("::AIVCtimedoutLoop::");
out.println(" <TimedoutLoop>" + "yes" + "</TimedoutLoop>");
} else {
out.println(" <TimedoutLoop>" + "no" + "</TimedoutLoop>");
}
for (String supp : ivc) {
out.println(" <MustElem>" + supp + "</MustElem>");
}
for (AllIVCs ivcSet : allIvcs) {
out.println(" <IvcSet number=\"" + count + "\">");
for (String invariant : ivcSet.getAllIVCList()) {
out.println(" <Invariant>" + escape(invariant) + "</Invariant>");
}
for (String supp : ivcSet.getAllIVCSet()) {
out.println(" <Ivc>" + supp + "</Ivc>");
}
out.println(" </IvcSet>");
count++;
}
}
out.println(" </Property>");
out.flush();
}
private String escape(Expr invariant) {
return invariant.toString().replace("<", "<").replace(">", ">");
}
private String escape(String invariant) {
return invariant.replace("<", "<").replace(">", ">");
}
@Override
public void writeInvalid(String prop, String source, Counterexample cex, List<String> conflicts, double runtime) {
out.println(" <Property name=\"" + prop + "\">");
out.println(" <Runtime unit=\"sec\">" + runtime + "</Runtime>");
out.println(" <Answer source=\"" + source + "\">falsifiable</Answer>");
out.println(" <K>" + cex.getLength() + "</K>");
writeCounterexample(cex);
writeConflicts(conflicts);
out.println(" </Property>");
out.flush();
}
private void writeConflicts(List<String> conflicts) {
if (conflicts.isEmpty()) {
return;
}
out.println(" <Conflicts>");
for (String conflict : conflicts) {
out.println(" <Conflict>" + conflict + "</Conflict>");
}
out.println(" </Conflicts>");
}
private void writeUnknown(String prop, int trueFor, Counterexample cex, double runtime) {
out.println(" <Property name=\"" + prop + "\">");
out.println(" <Runtime unit=\"sec\">" + runtime + "</Runtime>");
out.println(" <Answer>unknown</Answer>");
out.println(" <TrueFor>" + trueFor + "</TrueFor>");
if (cex != null) {
out.println(" <K>" + cex.getLength() + "</K>");
writeCounterexample(cex);
}
out.println(" </Property>");
out.flush();
}
private void writeCounterexample(Counterexample cex) {
out.println(" <Counterexample>");
for (Signal<Value> signal : cex.getSignals()) {
writeSignal(cex.getLength(), signal);
}
for (FunctionTable fn : cex.getFunctionTables()) {
writeFunction(fn);
}
out.println(" </Counterexample>");
}
private void writeFunction(FunctionTable table) {
out.println(" <Function name=\"" + table.getName() + "\">");
List<VarDecl> inputDecls = table.getInputs();
for (VarDecl inputDecl : inputDecls) {
out.println(" <Input name=\"" + inputDecl.id + "\" type=\"" + inputDecl.type + "\"/>");
}
VarDecl outputDecl = table.getOutput();
out.println(" <Output name=\"" + outputDecl.id + "\" type=\"" + outputDecl.type + "\"/>");
for (FunctionTableRow row : table.getRows()) {
out.println(" <FunctionValue>");
for (int i = 0; i < row.getInputs().size(); i++) {
Value input = row.getInputs().get(i);
out.println(" <InputValue>" + formatValue(input) + "</InputValue>");
}
out.println(" <OutputValue>" + formatValue(row.getOutput()) + "</OutputValue>");
out.println(" </FunctionValue>");
}
out.println(" </Function>");
}
private void writeSignal(int k, Signal<Value> signal) {
String name = signal.getName();
Type type = types.get(name);
out.println(" <Signal name=\"" + name + "\" type=\"" + type + "\">");
for (int i = 0; i < k; i++) {
Value value = signal.getValue(i);
if (value != null) {
out.println(" <Value time=\"" + i + "\">" + formatValue(value) + "</Value>");
}
}
out.println(" </Signal>");
}
/**
* pkind prints booleans as 0/1. We do the same for compatibility.
*/
private String formatValue(Value value) {
if (value instanceof BooleanValue) {
BooleanValue bv = (BooleanValue) value;
return bv.value ? "1" : "0";
} else {
return value.toString();
}
}
@Override
public void writeUnknown(List<String> props, int trueFor, Map<String, Counterexample> inductiveCounterexamples,
double runtime) {
for (String prop : props) {
writeUnknown(prop, trueFor, inductiveCounterexamples.get(prop), runtime);
}
}
@Override
public void writeBaseStep(List<String> props, int k) {
out.println(" <Progress source=\"bmc\" trueFor=\"" + k + "\">");
for (String prop : props) {
out.println(" <PropertyProgress name=\"" + prop + "\"/>");
}
out.println(" </Progress>");
out.flush();
}
@Override
public void writeInconsistent(String prop, String source, int k, double runtime) {
out.println(" <Property name=\"" + prop + "\">");
out.println(" <Runtime unit=\"sec\">" + runtime + "</Runtime>");
out.println(" <Answer source=\"" + source + "\">inconsistent</Answer>");
out.println(" <K>" + k + "</K>");
out.println(" </Property>");
out.flush();
}
}
| 7,436
| 31.056034
| 115
|
java
|
jkind
|
jkind-master/jkind/src/jkind/advice/AdviceReader.java
|
package jkind.advice;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.zip.GZIPInputStream;
import jkind.ExitCodes;
import jkind.StdErr;
public class AdviceReader {
public static Advice read(String inputFilename) {
try (InputStream in = new GZIPInputStream(new FileInputStream(inputFilename))) {
return AdviceEncoder.decode(in);
} catch (Exception e) {
StdErr.fatal(ExitCodes.INVALID_OPTIONS, "unable to parse advice file: " + e.getMessage());
throw new IllegalStateException();
}
}
}
| 533
| 25.7
| 93
|
java
|
jkind
|
jkind-master/jkind/src/jkind/advice/AdviceWriter.java
|
package jkind.advice;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.util.List;
import java.util.zip.GZIPOutputStream;
import jkind.ExitCodes;
import jkind.JKindException;
import jkind.StdErr;
import jkind.lustre.Expr;
import jkind.lustre.VarDecl;
public class AdviceWriter {
private Writer out;
private final Advice advice = new Advice();
public AdviceWriter(String outputFilename) {
try {
OutputStream stream = new GZIPOutputStream(new FileOutputStream(outputFilename));
this.out = new BufferedWriter(new OutputStreamWriter(stream));
} catch (IOException e) {
StdErr.fatal(ExitCodes.INVALID_OPTIONS, "unable to open advice file for writing: " + e.getMessage());
}
}
public void addVarDecls(List<VarDecl> varDecls) {
advice.addVarDecls(varDecls);
}
public void addInvariants(List<Expr> invariants) {
advice.addInvariants(invariants);
}
public void write() {
try {
out.write(AdviceEncoder.encode(advice));
out.close();
} catch (IOException e) {
throw new JKindException("Unable to write advice file", e);
}
}
}
| 1,206
| 24.145833
| 104
|
java
|
jkind
|
jkind-master/jkind/src/jkind/advice/VariableUsageChecker.java
|
package jkind.advice;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import jkind.lustre.Expr;
import jkind.lustre.IdExpr;
import jkind.lustre.VarDecl;
import jkind.lustre.visitors.ExprConjunctiveVisitor;
import jkind.util.Util;
public class VariableUsageChecker extends ExprConjunctiveVisitor {
private final Set<String> ids = new HashSet<>();
public VariableUsageChecker(List<VarDecl> varDecls) {
ids.addAll(Util.getIds(varDecls));
}
public boolean check(Expr expr) {
return expr.accept(this);
}
@Override
public Boolean visit(IdExpr e) {
return ids.contains(e.id);
}
}
| 616
| 20.275862
| 66
|
java
|
jkind
|
jkind-master/jkind/src/jkind/advice/AdviceEncoder.java
|
package jkind.advice;
import java.io.InputStream;
import org.antlr.v4.runtime.ANTLRInputStream;
import jkind.Main;
import jkind.lustre.Node;
import jkind.lustre.Program;
import jkind.lustre.builders.NodeBuilder;
public class AdviceEncoder {
public static String encode(Advice advice) {
NodeBuilder builder = new NodeBuilder("main");
builder.addLocals(advice.getVarDecls());
builder.addAssertions(advice.getInvariants());
return new Program(builder.build()).toString();
}
public static Advice decode(InputStream is) throws Exception {
Program program = Main.parseLustre(new ANTLRInputStream(is));
Node main = program.getMainNode();
Advice advice = new Advice();
advice.addVarDecls(main.locals);
advice.addInvariants(main.assertions);
return advice;
}
}
| 782
| 25.1
| 63
|
java
|
jkind
|
jkind-master/jkind/src/jkind/advice/Advice.java
|
package jkind.advice;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.function.Predicate;
import jkind.engines.invariant.InvariantSet;
import jkind.lustre.EnumType;
import jkind.lustre.Expr;
import jkind.lustre.NamedType;
import jkind.lustre.Node;
import jkind.lustre.SubrangeIntType;
import jkind.lustre.Type;
import jkind.lustre.VarDecl;
import jkind.util.Util;
public class Advice {
private final List<VarDecl> varDecls = new ArrayList<>();
private final InvariantSet invariants = new InvariantSet();
public void addVarDecls(List<VarDecl> newVarDecls) {
varDecls.addAll(newVarDecls);
}
public void addInvariant(Expr newInvariant) {
invariants.add(newInvariant);
}
public void addInvariants(List<Expr> newInvariants) {
invariants.addAll(newInvariants);
}
public List<VarDecl> getVarDecls() {
return varDecls;
}
public List<Expr> getInvariants() {
return invariants.getInvariants();
}
public void prune(Node node) {
Map<String, Type> map = Util.getTypeMap(node);
Predicate<VarDecl> noLongerExists = vd -> !map.containsKey(vd.id);
varDecls.removeIf(noLongerExists);
Predicate<VarDecl> typeChanged = vd -> !baseTypesMatch(map.get(vd.id), vd.type);
varDecls.removeIf(typeChanged);
VariableUsageChecker checker = new VariableUsageChecker(varDecls);
Predicate<Expr> usesUndefinedVariables = inv -> !checker.check(inv);
invariants.removeIf(usesUndefinedVariables);
}
private boolean baseTypesMatch(Type type1, Type type2) {
return getBaseName(type1).equals(getBaseName(type2));
}
private String getBaseName(Type type) {
if (type instanceof EnumType) {
EnumType et = (EnumType) type;
return et.id;
} else if (type instanceof NamedType) {
NamedType nt = (NamedType) type;
return nt.name;
} else if (type instanceof SubrangeIntType) {
return NamedType.INT.name;
} else {
throw new IllegalArgumentException("Unexpected type: " + type.getClass().getSimpleName());
}
}
}
| 1,990
| 25.905405
| 93
|
java
|
jkind
|
jkind-master/jkind/src/jkind/faultseeder/FaultReplacementLocations.java
|
package jkind.faultseeder;
import java.util.HashSet;
/*
* Fault types to consider:
* Arithmetic operator faults
* Relational operator faults
* Boolean operator faults
* Negation faults
* Delay faults
* Constant faults (+1 / -1)
* Node call parameter faults (misrouting parameters)
* Variable replacement faults
*
*
*/
public class FaultReplacementLocations {
public HashSet<Integer> arithmeticOp = new HashSet<>();
public HashSet<Integer> incrementOp = new HashSet<>();
public HashSet<Integer> relationalOp = new HashSet<>();
public HashSet<Integer> equalityOp = new HashSet<>();
public HashSet<Integer> booleanOp = new HashSet<>();
public HashSet<Integer> negationOp = new HashSet<>();
public HashSet<Integer> delayOp = new HashSet<>();
public HashSet<Integer> constantOp = new HashSet<>();
public HashSet<Integer> nodeCallParameter = new HashSet<>();
public HashSet<Integer> variableReplacement = new HashSet<>();
@Override
public String toString() {
return "arithmetic faults: " + arithmeticOp + "\nincrement faults: " + incrementOp + "\nrelational faults: "
+ relationalOp + "\nequality faults: " + equalityOp + "\nboolean faults: " + booleanOp
+ "\nnegation faults: " + negationOp + "\ndelay faults:" + delayOp + "\nconstant faults: " + constantOp
+ "\nnodeCallParameter faults: " + nodeCallParameter + "\nvariableReplacement faults: "
+ variableReplacement;
}
}
| 1,437
| 34.95
| 110
|
java
|
jkind
|
jkind-master/jkind/src/jkind/faultseeder/ComputeFaultSitesVisitor.java
|
package jkind.faultseeder;
/***
*
* ComputeFaultSitesVisitor
* ========================
*
*
*
*/
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.concurrent.ThreadLocalRandom;
import jkind.lustre.BinaryExpr;
import jkind.lustre.BinaryOp;
import jkind.lustre.BoolExpr;
import jkind.lustre.Expr;
import jkind.lustre.IdExpr;
import jkind.lustre.IntExpr;
import jkind.lustre.NamedType;
import jkind.lustre.Node;
import jkind.lustre.NodeCallExpr;
import jkind.lustre.RealExpr;
import jkind.lustre.Type;
import jkind.lustre.UnaryExpr;
import jkind.lustre.UnaryOp;
import jkind.lustre.visitors.AstMapVisitor;
import jkind.lustre.visitors.TypeReconstructor;
public class ComputeFaultSitesVisitor extends AstMapVisitor {
private final FaultSites sites = new FaultSites();
private final FaultReplacementLocations repls;
private final boolean linearMutantsOnly;
private TypeReconstructor reconstructor;
public ComputeFaultSitesVisitor(TypeReconstructor reconstructor, boolean linearMutantsOnly,
FaultReplacementLocations repls) {
this.reconstructor = reconstructor;
this.repls = repls;
this.linearMutantsOnly = linearMutantsOnly;
}
public FaultSites getFaultSites() {
return sites;
}
@Override
public Node visit(Node n) {
this.reconstructor.setNodeContext(n);
return super.visit(n);
}
// No need to override
// ArrayAccessExpr
// ArrayExpr
// ArrayUpdateExpr
// CastExpr
//
public BinaryOp randomRelationalOp() {
int ordinal = ThreadLocalRandom.current().nextInt(0, 6);
switch (ordinal) {
case 0:
return BinaryOp.EQUAL;
case 1:
return BinaryOp.NOTEQUAL;
case 2:
return BinaryOp.GREATER;
case 3:
return BinaryOp.LESS;
case 4:
return BinaryOp.GREATEREQUAL;
case 5:
return BinaryOp.LESSEQUAL;
default:
throw new IllegalArgumentException("Ordinal out of range");
}
}
public BinaryOp randomBooleanOp() {
int ordinal = ThreadLocalRandom.current().nextInt(0, 4);
switch (ordinal) {
case 0:
return BinaryOp.OR;
case 1:
return BinaryOp.AND;
case 2:
return BinaryOp.XOR;
case 3:
return BinaryOp.IMPLIES;
default:
throw new IllegalArgumentException("Ordinal out of range");
}
}
public BinaryOp randomArithOp() {
int ordinal = ThreadLocalRandom.current().nextInt(0, 6);
switch (ordinal) {
case 0:
return BinaryOp.PLUS;
case 1:
return BinaryOp.MINUS;
case 2:
return BinaryOp.MULTIPLY;
case 3:
return BinaryOp.DIVIDE;
case 4:
return BinaryOp.INT_DIVIDE;
case 5:
return BinaryOp.MODULUS;
default:
throw new IllegalArgumentException("Ordinal out of range");
}
}
public BinaryOp randomEqualityOp() {
int ordinal = ThreadLocalRandom.current().nextInt(0, 2);
switch (ordinal) {
case 0:
return BinaryOp.EQUAL;
case 1:
return BinaryOp.NOTEQUAL;
default:
throw new IllegalArgumentException("Ordinal out of range");
}
}
public BinaryExpr checkArithBinaryOpRepl(FaultSites oldSites, BinaryExpr e) {
if (this.repls.arithmeticOp.contains(sites.arithmeticOp) && this.sites.arithmeticOp != oldSites.arithmeticOp) {
while (true) {
BinaryOp op = randomArithOp();
Type t = this.reconstructor.visit(e);
// ensure correct type non-duplicate operator.
if ((t == NamedType.INT && op == BinaryOp.DIVIDE)
|| (t == NamedType.REAL && (op == BinaryOp.INT_DIVIDE || op == BinaryOp.MODULUS))
|| (op == e.op)) {
continue;
} else {
BinaryExpr result = new BinaryExpr(e.location, e.left, op, e.right);
System.out.println(
"Performing replacement " + sites.arithmeticOp + " from set: " + repls.arithmeticOp);
System.out.println("location: " + e.location);
System.out.println("Original expression: " + e);
System.out.println("Replacement expression: " + result + "\n");
if (linearMutantsOnly) {
// For now, we treat all multiplications, divisions, etc. as non-linear.
// We can revisit this by fixing the LinearChecker to allow
// expression-level checks.
if (op == BinaryOp.DIVIDE || op == BinaryOp.INT_DIVIDE || op == BinaryOp.MULTIPLY
|| op == BinaryOp.MODULUS) {
continue;
}
/*
* LinearChecker lc = new LinearChecker(Level.IGNORE);
* if (!lc.visit(result)) {
* // non-linear expression
* }
*/
}
return result;
}
}
}
return e;
}
public BinaryExpr checkEqualityBinaryOpRepl(FaultSites oldSites, BinaryExpr e) {
if (this.repls.equalityOp.contains(sites.equalityOp) && this.sites.equalityOp != oldSites.equalityOp) {
while (true) {
BinaryOp op = randomEqualityOp();
if (op != e.op) {
return new BinaryExpr(e.location, e.left, op, e.right);
}
}
}
return e;
}
public BinaryExpr checkRelationalBinaryOpRepl(FaultSites oldSites, BinaryExpr e) {
if (this.repls.relationalOp.contains(sites.relationalOp) && this.sites.relationalOp != oldSites.relationalOp) {
while (true) {
BinaryOp op = randomRelationalOp();
if ((op != e.op)) {
return new BinaryExpr(e.location, e.left, op, e.right);
}
}
}
return e;
}
public BinaryExpr checkBooleanBinaryOpRepl(FaultSites oldSites, BinaryExpr e) {
if (this.repls.booleanOp.contains(sites.booleanOp) && this.sites.booleanOp != oldSites.booleanOp) {
while (true) {
BinaryOp op = randomBooleanOp();
if ((op != e.op)) {
return new BinaryExpr(e.location, e.left, op, e.right);
}
}
}
return e;
}
public BinaryExpr checkBinaryOpRepl(FaultSites oldSites, BinaryExpr e) {
e = checkArithBinaryOpRepl(oldSites, e);
e = checkEqualityBinaryOpRepl(oldSites, e);
e = checkRelationalBinaryOpRepl(oldSites, e);
e = checkBooleanBinaryOpRepl(oldSites, e);
return e;
}
public Expr checkNegationOpRepl(FaultSites oldSites, Expr e) {
if (this.repls.negationOp.contains(this.sites.negationOp) && this.sites.negationOp != oldSites.negationOp) {
Type t = e.accept(this.reconstructor);
if (t == NamedType.BOOL) {
return new UnaryExpr(e.location, UnaryOp.NOT, e);
} else if (t == NamedType.INT || t == NamedType.REAL) {
return new UnaryExpr(e.location, UnaryOp.NEGATIVE, e);
} else {
throw new IllegalArgumentException("checkNegationOpRepl: expression is not of Boolean or Numeric Type");
}
}
return e;
}
public Expr checkIncrementRepl(FaultSites oldSites, Expr e) {
if (this.repls.incrementOp.contains(sites.incrementOp) && this.sites.incrementOp != oldSites.incrementOp) {
Type t = e.accept(this.reconstructor);
boolean sign = ThreadLocalRandom.current().nextBoolean();
BinaryOp op = sign ? BinaryOp.PLUS : BinaryOp.MINUS;
if (t == NamedType.INT) {
return new BinaryExpr(e.location, e, op, new IntExpr(e.location, BigInteger.ONE));
} else if (t == NamedType.REAL) {
return new BinaryExpr(e.location, e, op, new RealExpr(e.location, BigDecimal.ONE));
} else {
throw new IllegalArgumentException("checkConstantRepl: non-numeric type");
}
}
return e;
}
public Expr checkConstantRepl(FaultSites oldSites, Expr e) {
if (this.repls.constantOp.contains(sites.constantOp) && this.sites.constantOp != oldSites.constantOp) {
Type t = e.accept(this.reconstructor);
DefaultValueExprVisitor exprVisitor = new DefaultValueExprVisitor();
// currently not all types supported.
try {
e = t.accept(exprVisitor);
} catch (IllegalArgumentException ie) {
}
}
return e;
}
// TODO: MWW: this would be better if I made it an initialized delay.
// Future work: requires a "default value for type" visitor to construct
// the initial value. See DefaultValueVisitor.java.
public Expr checkDelayRepl(FaultSites oldSites, Expr e) {
if (this.repls.delayOp.contains(sites.constantOp) && this.sites.delayOp != oldSites.delayOp) {
return new UnaryExpr(UnaryOp.PRE, e);
}
return e;
}
// TODO: For now I am leaving out variable replacement faults and node parameter faults.
@SuppressWarnings("unused")
public Expr checkReplacementRepl(FaultSites oldSites, IdExpr e) {
return e;
}
@SuppressWarnings("unused")
public Expr checkNodeParameterRepl(FaultSites oldSites, NodeCallExpr e) {
return e;
}
public Expr checkRepl(FaultSites oldSites, Expr e) {
e = checkNegationOpRepl(oldSites, e);
e = checkIncrementRepl(oldSites, e);
e = checkConstantRepl(oldSites, e);
e = checkDelayRepl(oldSites, e);
// These are only for special cases: replacement only works for ID expressions,
// and parameter swapping only works for node calls.
// e = checkReplacementRepl(oldSites, e);
// e = checkNodeParameterRepl(oldSites, e);
return e;
}
@Override
public Expr visit(BinaryExpr e) {
e = (BinaryExpr) super.visit(e);
FaultSites oldSites = new FaultSites(sites);
switch (e.op) {
case PLUS:
case MINUS:
case MULTIPLY:
case DIVIDE:
case INT_DIVIDE:
case MODULUS: {
sites.arithmeticOp++;
sites.constantOp++;
sites.delayOp++;
sites.negationOp++;
sites.incrementOp++;
break;
}
case EQUAL:
case NOTEQUAL:
case GREATER:
case LESS:
case GREATEREQUAL:
case LESSEQUAL: {
Type t = e.left.accept(this.reconstructor);
if (t instanceof NamedType) {
NamedType nt = (NamedType) t;
if (nt == NamedType.INT || nt == NamedType.REAL) {
sites.relationalOp++;
sites.delayOp++;
}
sites.equalityOp++;
}
break;
}
case OR:
case AND:
case XOR:
case IMPLIES: {
sites.booleanOp++;
sites.constantOp++;
sites.delayOp++;
sites.negationOp++;
sites.equalityOp++;
break;
}
case ARROW: {
break;
}
}
Expr result = checkBinaryOpRepl(oldSites, e);
result = checkRepl(oldSites, result);
// if (result != e) {
// System.out.println("Modified result: " + result);
// }
return result;
}
@Override
public Expr visit(BoolExpr e) {
Expr result = super.visit(e);
FaultSites oldSites = new FaultSites(sites);
sites.booleanOp++;
sites.constantOp++;
return checkRepl(oldSites, result);
}
// No cast expression override.
// No condact expression override
@Override
public Expr visit(IdExpr e) {
FaultSites oldSites = new FaultSites(sites);
sites.variableReplacement++;
sites.delayOp++;
sites.constantOp++;
Type t = this.reconstructor.visit(e);
if (t == NamedType.INT || t == NamedType.REAL) {
sites.incrementOp++;
sites.negationOp++;
} else if (t == NamedType.BOOL) {
sites.negationOp++;
}
return checkRepl(oldSites, e);
}
// no override of ITE expression
@Override
public Expr visit(IntExpr e) {
FaultSites oldSites = new FaultSites(sites);
sites.delayOp++;
sites.constantOp++;
sites.incrementOp++;
sites.negationOp++;
return checkRepl(oldSites, e);
}
@Override
public Expr visit(NodeCallExpr e) {
FaultSites oldSites = new FaultSites(sites);
e = (NodeCallExpr) super.visit(e);
sites.nodeCallParameter++;
return checkRepl(oldSites, e);
}
@Override
public Expr visit(RealExpr e) {
FaultSites oldSites = new FaultSites(sites);
sites.delayOp++;
sites.constantOp++;
sites.incrementOp++;
sites.negationOp++;
return checkRepl(oldSites, e);
}
// @Override
// public Expr visit(RecordAccessExpr e) {
// @Override
// public Expr visit(RecordExpr e) {
// @Override
// public Expr visit(RecordUpdateExpr e) {
// @Override
// public Expr visit(TupleExpr e) {
// @Override
// public Expr visit(UnaryExpr e) {
}
| 11,379
| 25.526807
| 113
|
java
|
jkind
|
jkind-master/jkind/src/jkind/faultseeder/DefaultValueExprVisitor.java
|
package jkind.faultseeder;
import java.math.BigDecimal;
import java.math.BigInteger;
import jkind.lustre.ArrayType;
import jkind.lustre.BoolExpr;
import jkind.lustre.EnumType;
import jkind.lustre.Expr;
import jkind.lustre.IntExpr;
import jkind.lustre.NamedType;
import jkind.lustre.RealExpr;
import jkind.lustre.RecordType;
import jkind.lustre.SubrangeIntType;
import jkind.lustre.TupleType;
import jkind.lustre.visitors.TypeVisitor;
public class DefaultValueExprVisitor implements TypeVisitor<Expr> {
@Override
public Expr visit(ArrayType e) {
throw new IllegalArgumentException();
}
@Override
public Expr visit(EnumType e) {
return new IntExpr(BigInteger.ZERO);
}
@Override
public Expr visit(NamedType e) {
switch (e.name) {
case "bool":
return new BoolExpr(false);
case "int":
return new IntExpr(BigInteger.ZERO);
case "real":
return new RealExpr(BigDecimal.ZERO);
default:
throw new IllegalArgumentException("Unable to create default value for type: " + e.name);
}
}
@Override
public Expr visit(RecordType e) {
throw new IllegalArgumentException();
}
@Override
public Expr visit(TupleType e) {
throw new IllegalArgumentException();
}
@Override
public Expr visit(SubrangeIntType e) {
return new IntExpr(e.low);
}
}
| 1,278
| 21.051724
| 92
|
java
|
jkind
|
jkind-master/jkind/src/jkind/faultseeder/FaultSites.java
|
package jkind.faultseeder;
/*
* Fault types to consider:
* Arithmetic operator faults
* Relational operator faults
* Boolean operator faults
* Negation faults
* Delay faults
* Constant faults (+1 / -1)
* Node call parameter faults (misrouting parameters)
* Variable replacement faults
*
*
*/
public class FaultSites {
public int arithmeticOp = 0;
public int incrementOp = 0;
public int relationalOp = 0;
public int equalityOp = 0;
public int booleanOp = 0;
public int negationOp = 0;
public int delayOp = 0;
public int constantOp = 0;
public int nodeCallParameter = 0;
public int variableReplacement = 0;
public FaultSites() {
}
public FaultSites(FaultSites other) {
this.arithmeticOp = other.arithmeticOp;
this.incrementOp = other.incrementOp;
this.relationalOp = other.relationalOp;
this.equalityOp = other.equalityOp;
this.booleanOp = other.booleanOp;
this.negationOp = other.negationOp;
this.delayOp = other.delayOp;
this.constantOp = other.constantOp;
this.nodeCallParameter = other.nodeCallParameter;
this.variableReplacement = other.variableReplacement;
}
public int totalFaults() {
return arithmeticOp + incrementOp + relationalOp + equalityOp + booleanOp + negationOp + delayOp + constantOp
+ nodeCallParameter + variableReplacement;
}
}
| 1,328
| 25.58
| 111
|
java
|
jkind
|
jkind-master/jkind/src/jkind/util/CounterexampleExtractor.java
|
package jkind.util;
import java.util.ArrayList;
import java.util.List;
import jkind.lustre.EnumType;
import jkind.lustre.Type;
import jkind.lustre.VarDecl;
import jkind.lustre.values.EnumValue;
import jkind.lustre.values.IntegerValue;
import jkind.lustre.values.Value;
import jkind.results.Counterexample;
import jkind.results.FunctionTable;
import jkind.results.FunctionTableRow;
import jkind.results.Signal;
import jkind.solvers.Model;
import jkind.translation.Specification;
public class CounterexampleExtractor {
public static Counterexample extract(Specification spec, int k, Model model) {
return new CounterexampleExtractor(spec).extractCounterexample(k, model);
}
private final Specification spec;
private CounterexampleExtractor(Specification spec) {
this.spec = spec;
}
private Counterexample extractCounterexample(int k, Model model) {
Counterexample cex = new Counterexample(k);
for (String var : model.getVariableNames()) {
StreamIndex si = StreamIndex.decode(var);
if (si != null && si.getIndex() >= 0 && !isInternal(si.getStream())) {
Signal<Value> signal = cex.getOrCreateSignal(si.getStream());
Value value = convert(spec.typeMap.get(si.getStream()), model.getValue(var));
signal.putValue(si.getIndex(), value);
}
}
for (FunctionTable table : model.getFunctionTables()) {
List<VarDecl> inputs = table.getInputs();
VarDecl output = table.getOutput();
FunctionTable newTable = new FunctionTable(table.getName(), inputs, output);
for (FunctionTableRow row : table.getRows()) {
List<Value> newInputValues = new ArrayList<>();
for (int i = 0; i < inputs.size(); i++) {
newInputValues.add(convert(inputs.get(i).type, row.getInputs().get(i)));
}
Value newOutputValue = convert(output.type, row.getOutput());
newTable.addRow(newInputValues, newOutputValue);
}
cex.addFunctionTable(newTable);
}
return cex;
}
private boolean isInternal(String stream) {
return stream.startsWith("%");
}
private Value convert(Type type, Value value) {
if (type instanceof EnumType && value != null) {
EnumType et = (EnumType) type;
IntegerValue iv = (IntegerValue) value;
return new EnumValue(et.values.get(iv.value.intValue()));
}
return value;
}
}
| 2,261
| 29.16
| 81
|
java
|
jkind
|
jkind-master/jkind/src/jkind/util/LinkedBiMap.java
|
package jkind.util;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* A bi-directional map that preserves the order of keys and values
*/
public class LinkedBiMap<K, V> implements Map<K, V> {
private Map<K, V> map;
private Map<V, K> inverse;
public LinkedBiMap() {
this.map = new LinkedHashMap<>();
this.inverse = new LinkedHashMap<>();
}
private LinkedBiMap(Map<K, V> map, Map<V, K> inverse) {
this.map = map;
this.inverse = inverse;
}
public LinkedBiMap<V, K> inverse() {
return new LinkedBiMap<>(inverse, map);
}
@Override
public void clear() {
map.clear();
inverse.clear();
}
@Override
public boolean containsKey(Object key) {
return map.containsKey(key);
}
@Override
public boolean containsValue(Object value) {
return map.containsValue(value);
}
@Override
public Set<Entry<K, V>> entrySet() {
return Collections.unmodifiableSet(map.entrySet());
}
@Override
public V get(Object key) {
return map.get(key);
}
public K getKey(V value) {
return inverse.get(value);
}
@Override
public boolean isEmpty() {
return map.isEmpty();
}
@Override
public Set<K> keySet() {
return Collections.unmodifiableSet(map.keySet());
}
@Override
public V put(K key, V value) {
if (inverse.containsKey(value)) {
throw new IllegalArgumentException("BiMap already has a mapping to value: " + value);
}
if (map.containsKey(key)) {
inverse.remove(map.get(key));
}
map.put(key, value);
inverse.put(value, key);
return value;
}
@Override
public void putAll(Map<? extends K, ? extends V> other) {
for (Entry<? extends K, ? extends V> e : other.entrySet()) {
put(e.getKey(), e.getValue());
}
}
@Override
public V remove(Object key) {
if (map.containsKey(key)) {
inverse.remove(map.get(key));
return map.remove(key);
} else {
return null;
}
}
@Override
public int size() {
return map.size();
}
@Override
public Collection<V> values() {
return Collections.unmodifiableCollection(map.values());
}
public List<K> keyList() {
return Util.safeList(map.keySet());
}
public List<V> valueList() {
return Util.safeList(map.values());
}
}
| 2,266
| 17.735537
| 88
|
java
|
jkind
|
jkind-master/jkind/src/jkind/util/Tuple.java
|
package jkind.util;
public class Tuple<X, Y> {
private final X x;
private final Y y;
public Tuple(X x, Y y) {
this.x = x;
this.y = y;
}
public X firstElement() {
return x;
}
public Y secondElement() {
return y;
}
}
| 234
| 11.368421
| 27
|
java
|
jkind
|
jkind-master/jkind/src/jkind/util/ModelReconstructionEvaluator.java
|
package jkind.util;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import jkind.JKindException;
import jkind.lustre.BinaryExpr;
import jkind.lustre.BinaryOp;
import jkind.lustre.Equation;
import jkind.lustre.Expr;
import jkind.lustre.FunctionCallExpr;
import jkind.lustre.IdExpr;
import jkind.lustre.Type;
import jkind.lustre.UnaryExpr;
import jkind.lustre.UnaryOp;
import jkind.lustre.values.BooleanValue;
import jkind.lustre.values.Value;
import jkind.lustre.visitors.Evaluator;
import jkind.slicing.Dependency;
import jkind.slicing.DependencySet;
import jkind.slicing.DependencyType;
import jkind.slicing.DependencyVisitor;
import jkind.solvers.Model;
import jkind.solvers.SimpleModel;
import jkind.translation.Specification;
public class ModelReconstructionEvaluator extends Evaluator {
public static Model reconstruct(Specification userSpec, Specification analysisSpec, Model model, String property,
int k, boolean concrete) {
Set<String> inlinedVariables = Util.setDifference(userSpec.typeMap.keySet(), analysisSpec.typeMap.keySet());
ModelReconstructionEvaluator eval = new ModelReconstructionEvaluator(userSpec, inlinedVariables, model,
concrete);
eval.reconstructValues(property, k);
return eval.model;
}
private final Specification spec;
private final Model originalModel;
private final SimpleModel model;
private final boolean concrete;
private final Set<String> inlinedVariables;
private final Map<String, Expr> equations = new HashMap<>();
private final Set<StreamIndex> evaluating = new HashSet<>();
private int step;
private ModelReconstructionEvaluator(Specification userSpec, Set<String> inlinedVariables, Model originalModel,
boolean concrete) {
this.spec = userSpec;
this.inlinedVariables = inlinedVariables;
this.originalModel = originalModel;
this.model = new SimpleModel(userSpec.functions);
this.concrete = concrete;
for (Equation eq : userSpec.node.equations) {
equations.put(eq.lhs.get(0).id, eq.expr);
}
}
private void reconstructValues(String property, int k) {
DependencySet dependencies = spec.dependencyMap.get(property);
for (step = 0; step < k; step++) {
for (Dependency dependency : dependencies) {
if (dependency.type == DependencyType.VARIABLE) {
try {
Value v1 = eval(new IdExpr(dependency.name));
// Compare computed value (v1) with solver value (v2) when possible
if (!inlinedVariables.contains(dependency.name)) {
Value v2 = originalModel.getValue(new StreamIndex(dependency.name, step));
if (v2 != null && !v1.equals(v2)) {
throw new JKindException(
"Unable to reconstruct counterexample: variable value changed: "
+ dependency.name);
}
}
} catch (ArithmeticException ae) {
// Division by zero, ignore
}
}
}
for (Expr assertion : spec.node.assertions) {
DependencySet assertionDependencies = DependencyVisitor.get(assertion);
if (dependencies.containsAll(assertionDependencies)) {
BooleanValue bv = (BooleanValue) eval(assertion);
if (!bv.value) {
throw new JKindException("Unable to reconstruct counterexample: assertion became false");
}
}
}
}
}
@Override
public Value visit(IdExpr e) {
StreamIndex si = new StreamIndex(e.id, step);
Value value = model.getValue(si);
if (value != null) {
return value;
}
Expr expr = equations.get(e.id);
if (expr == null) {
// Input variable
value = originalModel.getValue(si);
} else {
// Equation variable
if (inlinedVariables.contains(e.id)) {
// Inlined variables are always evaluated, ignoring any
// restrictions on loops since the model knows nothing about
// such variables
value = eval(expr);
} else if (step >= 0 && !evaluating.contains(si)) {
evaluating.add(si);
value = eval(expr);
evaluating.remove(si);
} else {
value = originalModel.getValue(si);
}
}
if (value == null) {
throw new JKindException("Unable to reconstruct counterexample: variable has null value");
}
model.putValue(si, value);
return value;
}
@Override
public Value visit(BinaryExpr e) {
if (e.op == BinaryOp.ARROW) {
if (!concrete) {
// Inductive counterexamples never reach the true initial step
return eval(e.right);
}
if (step == 0) {
return eval(e.left);
} else {
return eval(e.right);
}
} else {
return super.visit(e);
}
}
@Override
public Value visit(UnaryExpr e) {
if (e.op == UnaryOp.PRE) {
step--;
Value value = eval(e.expr);
step++;
return value;
} else {
return super.visit(e);
}
}
@Override
public Value visit(FunctionCallExpr e) {
String name = SexpUtil.encodeFunction(e.function);
List<Value> inputs = visitExprs(e.args);
Value output = model.evaluateFunction(name, inputs);
if (output == null) {
output = originalModel.evaluateFunction(name, inputs);
if (output == null) {
Type outputType = model.getFunctionTable(name).getOutput().type;
output = Util.getDefaultValue(outputType);
}
model.getFunctionTable(name).addRow(inputs, output);
}
return output;
}
}
| 5,214
| 27.342391
| 114
|
java
|
jkind
|
jkind-master/jkind/src/jkind/util/StreamIndex.java
|
package jkind.util;
import java.util.ArrayList;
import java.util.List;
import jkind.sexp.Sexp;
import jkind.sexp.Symbol;
public class StreamIndex {
private final String stream;
private final int index;
public StreamIndex(String stream, int index) {
this.stream = stream;
this.index = index;
}
public String getStream() {
return stream;
}
public int getIndex() {
return index;
}
public Symbol getEncoded() {
return new Symbol("$" + stream + getSuffix(index));
}
public static String getSuffix(int index) {
if (index >= 0) {
return "$" + index;
} else {
// Using - in symbol names causes parse issues, so we use ~ instead
return "$~" + -index;
}
}
public static StreamIndex decode(String encoded) {
if (!isEncodedStreamIndex(encoded)) {
return null;
}
int split = encoded.indexOf("$", 1);
String stream = encoded.substring(1, split);
int index = getIndex(encoded.substring(split + 1));
return new StreamIndex(stream, index);
}
public static StreamIndex decode(Symbol encoded) {
return decode(encoded.str);
}
public static List<StreamIndex> fromList(List<String> streams, int index) {
List<StreamIndex> result = new ArrayList<>();
for (String stream : streams) {
result.add(new StreamIndex(stream, index));
}
return result;
}
public static List<Symbol> getEncoded(List<StreamIndex> streamIndexes) {
List<Symbol> result = new ArrayList<>();
for (StreamIndex streamIndex : streamIndexes) {
result.add(streamIndex.getEncoded());
}
return result;
}
public static Sexp conjoinEncodings(List<String> streams, int index) {
return SexpUtil.conjoin(getEncoded(fromList(streams, index)));
}
private static boolean isEncodedStreamIndex(String var) {
return var.startsWith("$") && !SexpUtil.isEncodedFunction(var);
}
private static int getIndex(String indexStr) {
if (indexStr.startsWith("~")) {
return -Integer.parseInt(indexStr.substring(1));
} else {
return Integer.parseInt(indexStr);
}
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + index;
result = prime * result + ((stream == null) ? 0 : stream.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (!(obj instanceof StreamIndex)) {
return false;
}
StreamIndex other = (StreamIndex) obj;
if (index != other.index) {
return false;
}
if (stream == null) {
if (other.stream != null) {
return false;
}
} else if (!stream.equals(other.stream)) {
return false;
}
return true;
}
}
| 2,654
| 21.125
| 76
|
java
|
jkind
|
jkind-master/jkind/src/jkind/util/SexpUtil.java
|
package jkind.util;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import jkind.lustre.Expr;
import jkind.sexp.Cons;
import jkind.sexp.Sexp;
import jkind.sexp.Symbol;
import jkind.translation.Lustre2Sexp;
public class SexpUtil {
public static Sexp conjoin(List<? extends Sexp> conjuncts) {
if (conjuncts.isEmpty()) {
return new Symbol("true");
} else if (conjuncts.size() == 1) {
return conjuncts.get(0);
} else {
return new Cons("and", conjuncts);
}
}
public static Sexp disjoin(List<Sexp> disjuncts) {
if (disjuncts.isEmpty()) {
return new Symbol("false");
} else if (disjuncts.size() == 1) {
return disjuncts.get(0);
} else {
return new Cons("or", disjuncts);
}
}
public static Sexp conjoinInvariants(Collection<Expr> invariants, int k) {
List<Sexp> conjuncts = new ArrayList<>();
for (Expr invariant : invariants) {
conjuncts.add(invariant.accept(new Lustre2Sexp(k)));
}
return SexpUtil.conjoin(conjuncts);
}
public static String encodeFunction(String name) {
return "$$" + name;
}
public static String decodeFunction(String encoded) {
if (!isEncodedFunction(encoded)) {
return null;
}
return encoded.substring(2);
}
public static boolean isEncodedFunction(String name) {
return name.startsWith("$$");
}
}
| 1,321
| 22.192982
| 75
|
java
|
jkind
|
jkind-master/jkind/src/jkind/slicing/DependencyMap.java
|
package jkind.slicing;
import java.util.ArrayDeque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Set;
import java.util.Stack;
import jkind.lustre.Equation;
import jkind.lustre.Expr;
import jkind.lustre.Function;
import jkind.lustre.IdExpr;
import jkind.lustre.Node;
import jkind.lustre.VarDecl;
import jkind.util.Util;
public class DependencyMap {
private Map<Dependency, DependencySet> map = new HashMap<>();
public DependencyMap(Node node, List<String> roots, List<Function> functions) {
computeOneStepDependencies(node, functions);
analyzeAssertions(node.assertions);
closeDependencies(roots);
}
private void computeOneStepDependencies(Node node, List<Function> functions) {
for (VarDecl input : node.inputs) {
map.put(Dependency.variable(input.id), new DependencySet());
}
for (Function fn : functions) {
map.put(Dependency.function(fn.id), new DependencySet());
}
for (Equation eq : node.equations) {
DependencySet deps = DependencyVisitor.get(eq.expr);
for (IdExpr idExpr : eq.lhs) {
map.put(Dependency.variable(idExpr.id), deps);
}
}
}
/*
* Assertions cause everything they (transitively) touch to be related. For
* example, suppose x depends on y and y depends on z. If we assert that x
* is always true, then x, y, and z all depends on each other. We encode
* this by adding one step dependencies to the map and closing them later.
*/
private void analyzeAssertions(List<Expr> assertions) {
for (Expr assertion : assertions) {
DependencySet assertionDependencies = DependencyVisitor.get(assertion);
// Everything mentioned in an assertion creates bidirectional
// dependencies for all its dependencies
Queue<Dependency> todo = new ArrayDeque<>(assertionDependencies.getSet());
Set<Dependency> seen = new HashSet<>();
while (!todo.isEmpty()) {
Dependency curr = todo.remove();
if (!seen.add(curr)) {
continue;
}
DependencySet deps = map.get(curr);
for (Dependency dep : deps) {
map.get(dep).add(curr);
}
todo.addAll(deps.getSet());
}
// All elements in an assertion depend on all other elements in it
for (Dependency dep : assertionDependencies) {
map.get(dep).addAll(assertionDependencies);
}
}
}
private void closeDependencies(List<String> roots) {
Map<Dependency, DependencySet> transMap = new HashMap<>();
for (String variableRoot : roots) {
Dependency dep = Dependency.variable(variableRoot);
transMap.put(dep, computeClosure(dep));
}
map = transMap;
}
private DependencySet computeClosure(Dependency dep) {
DependencySet closure = new DependencySet();
closure.add(dep);
Stack<Dependency> todo = new Stack<>();
todo.push(dep);
while (!todo.empty()) {
Dependency curr = todo.pop();
if (map.containsKey(curr)) {
for (Dependency next : map.get(curr)) {
if (!closure.contains(next)) {
closure.add(next);
todo.push(next);
}
}
}
}
return closure;
}
private DependencyMap() {
}
public static DependencyMap full(Node node, List<Function> functions) {
DependencyMap result = new DependencyMap();
DependencySet set = new DependencySet();
for (VarDecl vd : Util.getVarDecls(node)) {
set.add(Dependency.variable(vd.id));
}
for (Function fn : functions) {
set.add(Dependency.function(fn.id));
}
for (VarDecl vd : Util.getVarDecls(node)) {
result.map.put(Dependency.variable(vd.id), set);
}
return result;
}
public DependencySet get(Dependency dependency) {
return map.get(dependency);
}
public DependencySet get(String var) {
return get(Dependency.variable(var));
}
public DependencySet get(List<String> vars) {
DependencySet result = new DependencySet();
for (String var : vars) {
result.addAll(get(var));
}
return result;
}
}
| 3,898
| 25.52381
| 80
|
java
|
jkind
|
jkind-master/jkind/src/jkind/slicing/LustreSlicer.java
|
package jkind.slicing;
import java.util.ArrayList;
import java.util.List;
import jkind.lustre.Equation;
import jkind.lustre.Expr;
import jkind.lustre.IdExpr;
import jkind.lustre.Node;
import jkind.lustre.VarDecl;
import jkind.lustre.visitors.AstMapVisitor;
public class LustreSlicer extends AstMapVisitor {
public static Node slice(Node node, DependencyMap depMap) {
return new LustreSlicer(getPropertyDependencies(node, depMap)).visit(node);
}
private static DependencySet getPropertyDependencies(Node node, DependencyMap depMap) {
DependencySet keep = new DependencySet();
for (String prop : node.properties) {
keep.addAll(depMap.get(prop));
}
return keep;
}
private final DependencySet keep;
private LustreSlicer(DependencySet keep) {
this.keep = keep;
}
@Override
protected List<VarDecl> visitVarDecls(List<VarDecl> decls) {
List<VarDecl> sliced = new ArrayList<>();
for (VarDecl decl : decls) {
if (keep.contains(Dependency.variable(decl.id))) {
sliced.add(decl);
}
}
return sliced;
}
@Override
protected List<Equation> visitEquations(List<Equation> equations) {
List<Equation> sliced = new ArrayList<>();
for (Equation eq : equations) {
if (containsAny(keep, eq.lhs)) {
sliced.add(eq);
}
}
return sliced;
}
@Override
protected List<Expr> visitAssertions(List<Expr> assertions) {
List<Expr> sliced = new ArrayList<>();
for (Expr assertion : assertions) {
DependencySet deps = DependencyVisitor.get(assertion);
if (deps.isEmpty() || keep.contains(deps.first())) {
sliced.add(assertion);
}
}
return sliced;
}
@Override
protected List<String> visitIvc(List<String> ivc) {
List<String> sliced = new ArrayList<>();
for (String e : ivc) {
if (keep.contains(Dependency.variable(e))) {
sliced.add(e);
}
}
return sliced;
}
private static boolean containsAny(DependencySet set, List<IdExpr> lhs) {
for (IdExpr idExpr : lhs) {
if (set.contains(Dependency.variable(idExpr.id))) {
return true;
}
}
return false;
}
}
| 2,047
| 22.54023
| 88
|
java
|
jkind
|
jkind-master/jkind/src/jkind/slicing/DependencyVisitor.java
|
package jkind.slicing;
import jkind.lustre.Expr;
import jkind.lustre.FunctionCallExpr;
import jkind.lustre.IdExpr;
import jkind.lustre.visitors.ExprIterVisitor;
public class DependencyVisitor extends ExprIterVisitor {
public static DependencySet get(Expr expr) {
DependencyVisitor visitor = new DependencyVisitor();
expr.accept(visitor);
return visitor.set;
}
private DependencySet set = new DependencySet();
@Override
public Void visit(FunctionCallExpr e) {
set.add(Dependency.function(e.function));
super.visit(e);
return null;
}
@Override
public Void visit(IdExpr e) {
set.add(Dependency.variable(e.id));
return null;
}
}
| 655
| 20.866667
| 56
|
java
|
jkind
|
jkind-master/jkind/src/jkind/slicing/DependencyType.java
|
package jkind.slicing;
public enum DependencyType {
VARIABLE, FUNCTION
}
| 75
| 11.666667
| 28
|
java
|
jkind
|
jkind-master/jkind/src/jkind/slicing/Dependency.java
|
package jkind.slicing;
public class Dependency {
public final String name;
public final DependencyType type;
public Dependency(String name, DependencyType type) {
this.name = name;
this.type = type;
}
public static Dependency variable(String name) {
return new Dependency(name, DependencyType.VARIABLE);
}
public static Dependency function(String name) {
return new Dependency(name, DependencyType.FUNCTION);
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((type == null) ? 0 : type.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (!(obj instanceof Dependency)) {
return false;
}
Dependency other = (Dependency) obj;
if (name == null) {
if (other.name != null) {
return false;
}
} else if (!name.equals(other.name)) {
return false;
}
if (type != other.type) {
return false;
}
return true;
}
@Override
public String toString() {
return name;
}
}
| 1,159
| 18.661017
| 67
|
java
|
jkind
|
jkind-master/jkind/src/jkind/slicing/DependencySet.java
|
package jkind.slicing;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class DependencySet implements Iterable<Dependency> {
private final Set<Dependency> set = new HashSet<>();
public boolean add(Dependency dep) {
return set.add(dep);
}
public boolean addAll(DependencySet other) {
return set.addAll(other.set);
}
public boolean contains(Dependency dep) {
return set.contains(dep);
}
public boolean isEmpty() {
return set.isEmpty();
}
public Set<Dependency> getSet() {
return set;
}
public boolean containsAll(DependencySet other) {
return set.containsAll(other.set);
}
@Override
public Iterator<Dependency> iterator() {
return set.iterator();
}
public Dependency first() {
return iterator().next();
}
@Override
public String toString() {
return set.toString();
}
}
| 851
| 16.75
| 60
|
java
|
jkind
|
jkind-master/jkind/src/jkind/jlustre2kind/KindEncodeIdsVisitor.java
|
package jkind.jlustre2kind;
import jkind.lustre.Equation;
import jkind.lustre.IdExpr;
import jkind.lustre.VarDecl;
import jkind.lustre.visitors.AstMapVisitor;
public class KindEncodeIdsVisitor extends AstMapVisitor {
@Override
public VarDecl visit(VarDecl e) {
return new VarDecl(e.location, encode(e.id), e.type);
}
@Override
public Equation visit(Equation e) {
return super.visit(new Equation(e.location, map(this::visit, e.lhs), e.expr));
}
@Override
public IdExpr visit(IdExpr e) {
return new IdExpr(e.location, encode(e.id));
}
@Override
protected String visitProperty(String e) {
return encode(e);
}
private String encode(String str) {
str = str.replaceAll("\\.", "~dot~");
str = str.replaceAll("\\[", "~lbrack~");
str = str.replaceAll("\\]", "~rbrack~");
return str;
}
}
| 814
| 21.638889
| 80
|
java
|
jkind
|
jkind-master/jkind/src/jkind/jlustre2kind/ObfuscateIdsVisitor.java
|
package jkind.jlustre2kind;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import jkind.lustre.Equation;
import jkind.lustre.IdExpr;
import jkind.lustre.VarDecl;
import jkind.lustre.visitors.AstMapVisitor;
public class ObfuscateIdsVisitor extends AstMapVisitor {
private final Map<String, String> obfuscated = new HashMap<>();
private String obfuscate(String str) {
return obfuscated.computeIfAbsent(str, s -> randomId());
}
private String randomId() {
return "x" + UUID.randomUUID().toString().replace("-", "");
}
@Override
public VarDecl visit(VarDecl e) {
return new VarDecl(e.location, obfuscate(e.id), e.type);
}
@Override
public Equation visit(Equation e) {
return super.visit(new Equation(e.location, map(this::visit, e.lhs), e.expr));
}
@Override
public IdExpr visit(IdExpr e) {
return new IdExpr(e.location, obfuscate(e.id));
}
@Override
protected String visitProperty(String e) {
return obfuscate(e);
}
@Override
protected String visitIvc(String e) {
return obfuscate(e);
}
@Override
protected String visitRealizabilityInput(String e) {
return obfuscate(e);
}
}
| 1,146
| 20.641509
| 80
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/MaxSatSolver.java
|
package jkind.solvers;
import jkind.sexp.Sexp;
public interface MaxSatSolver {
public void assertSoft(Sexp sexp);
public Result maxsatQuery(Sexp query);
}
| 160
| 15.1
| 39
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/Result.java
|
package jkind.solvers;
public abstract class Result {
}
| 58
| 8.833333
| 30
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/UnknownResult.java
|
package jkind.solvers;
public class UnknownResult extends Result {
final private Model model;
public UnknownResult(Model model) {
super();
this.model = model;
}
public UnknownResult() {
this(null);
}
public Model getModel() {
return model;
}
}
| 263
| 12.894737
| 43
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/Model.java
|
package jkind.solvers;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import jkind.lustre.Function;
import jkind.lustre.Type;
import jkind.lustre.values.Value;
import jkind.results.FunctionTable;
import jkind.util.SexpUtil;
import jkind.util.StreamIndex;
public abstract class Model {
protected Map<String, Type> varTypes;
protected Map<String, FunctionTable> functionTables = new HashMap<>();
public Model(Map<String, Type> varTypes, List<Function> functions) {
this.varTypes = Collections.unmodifiableMap(new HashMap<>(varTypes));
for (Function fn : functions) {
String encoded = SexpUtil.encodeFunction(fn.id);
functionTables.put(encoded, new FunctionTable(fn.id, fn.inputs, fn.outputs.get(0)));
}
}
public abstract Value getValue(String name);
public abstract Set<String> getVariableNames();
public Value getValue(StreamIndex si) {
return getValue(si.getEncoded().str);
}
public void addFunctionTable(String encoded, FunctionTable table) {
functionTables.put(encoded, table);
}
public Collection<FunctionTable> getFunctionTables() {
return functionTables.values();
}
public FunctionTable getFunctionTable(String name) {
return functionTables.get(name);
}
public Value evaluateFunction(String name, List<Value> inputs) {
FunctionTable functionTable = functionTables.get(name);
return functionTable.lookup(inputs);
}
}
| 1,477
| 26.37037
| 87
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/SimpleModel.java
|
package jkind.solvers;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import jkind.lustre.Function;
import jkind.lustre.values.Value;
import jkind.util.StreamIndex;
public class SimpleModel extends Model {
private final Map<String, Value> values = new HashMap<>();
public SimpleModel() {
super(Collections.emptyMap(), Collections.emptyList());
}
public SimpleModel(List<Function> functions) {
super(Collections.emptyMap(), functions);
}
public void putValue(StreamIndex si, Value value) {
values.put(si.getEncoded().str, value);
}
public void putValue(String encoded, Value value) {
values.put(encoded, value);
}
@Override
public Value getValue(String name) {
return values.get(name);
}
@Override
public Set<String> getVariableNames() {
return values.keySet();
}
}
| 877
| 19.904762
| 59
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/Solver.java
|
package jkind.solvers;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import jkind.lustre.Expr;
import jkind.lustre.Function;
import jkind.lustre.NamedType;
import jkind.lustre.Type;
import jkind.lustre.VarDecl;
import jkind.sexp.Cons;
import jkind.sexp.Sexp;
import jkind.sexp.Symbol;
import jkind.solvers.z3.Z3Solver;
import jkind.translation.Relation;
public abstract class Solver {
public abstract void initialize();
public abstract void assertSexp(Sexp sexp);
public abstract void define(VarDecl decl);
public abstract void declare(Function function);
public abstract void define(Relation relation);
/**
* A query focused on the SAT result. Produces a model for SAT. Does not
* return an unsat-core for UNSAT.
*/
public abstract Result query(Sexp sexp);
public abstract void push();
public abstract void pop();
public abstract void comment(String str);
public abstract void stop();
protected final Map<String, Type> varTypes = new HashMap<>();
protected final List<Function> functions = new ArrayList<>();
/**
* Check if the solver supports all of the operators in the expression.
* Useful since PDR may generate invariants using operators not supported by
* the solver.
*
* @param expr
*/
public boolean supports(Expr expr) {
return true;
}
public void declare(List<Function> functions) {
for (Function func : functions) {
declare(func);
}
}
public Symbol createActivationLiteral(String prefix, int i) {
String name = prefix + i;
define(new VarDecl(name, NamedType.BOOL));
return new Symbol(name);
}
/**
* A query focused on the UNSAT result. Produces no model for SAT. Computes
* a minimal unsat-core of activation literals for UNSAT.
*/
public Result unsatQuery(List<Symbol> activationLiterals, Sexp query) {
push();
assertSexp(new Cons("not", query));
Result result = quickCheckSat(activationLiterals);
if (result instanceof UnsatResult) {
UnsatResult unsat = (UnsatResult) result;
result = new UnsatResult(minimizeUnsatCore(unsat.getUnsatCore()));
}
pop();
return result;
}
/**
* Compute a minimal unsat-core for a check-sat under assumptions. This
* method assumes that check-sat under all the assumption returns UNSAT.
*/
protected List<Symbol> minimizeUnsatCore(List<Symbol> unsatCore) {
List<Symbol> result = new ArrayList<>(unsatCore);
if (!(this instanceof Z3Solver)) {
Iterator<Symbol> iterator = result.iterator();
while (iterator.hasNext()) {
Symbol curr = iterator.next();
if (quickCheckSat(without(result, curr)) instanceof UnsatResult) {
iterator.remove();
}
}
}
comment("Minimal unsat core: " + result);
return result;
}
/**
* Perform a check-sat under assumptions. Produces no model for SAT. Gets
* unsat-core of activation literals for UNSAT.
*/
protected abstract Result quickCheckSat(List<Symbol> activationLiterals);
protected <T> List<T> without(List<T> list, T elem) {
List<T> result = new ArrayList<>(list);
result.remove(elem);
return result;
}
}
| 3,126
| 24.631148
| 77
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/SolverParserErrorListener.java
|
package jkind.solvers;
import jkind.JKindException;
import org.antlr.v4.runtime.BaseErrorListener;
import org.antlr.v4.runtime.RecognitionException;
import org.antlr.v4.runtime.Recognizer;
public class SolverParserErrorListener extends BaseErrorListener {
@Override
public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol, int line, int charPositionInLine,
String msg, RecognitionException e) {
throw new JKindException("Solver output parse error line " + line + ":" + charPositionInLine + " " + msg);
}
}
| 537
| 32.625
| 111
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/SatResult.java
|
package jkind.solvers;
public class SatResult extends Result {
final private Model model;
public SatResult(Model model) {
super();
this.model = model;
}
public SatResult() {
this(null);
}
public Model getModel() {
return model;
}
}
| 251
| 12.263158
| 39
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/UnsatResult.java
|
package jkind.solvers;
import java.util.List;
import jkind.sexp.Symbol;
public class UnsatResult extends Result {
final private List<Symbol> unsatCore;
public UnsatResult() {
this.unsatCore = null;
}
public UnsatResult(List<Symbol> unsatCore) {
this.unsatCore = unsatCore;
}
public List<Symbol> getUnsatCore() {
return unsatCore;
}
}
| 353
| 15.090909
| 45
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/ModelEvaluator.java
|
package jkind.solvers;
import jkind.lustre.IdExpr;
import jkind.lustre.values.Value;
import jkind.lustre.visitors.Evaluator;
import jkind.util.StreamIndex;
public class ModelEvaluator extends Evaluator {
private final Model model;
private final int index;
public ModelEvaluator(Model model, int index) {
super();
this.model = model;
this.index = index;
}
@Override
public Value visit(IdExpr e) {
return model.getValue(new StreamIndex(e.id, index));
}
}
| 472
| 19.565217
| 54
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/ProcessBasedSolver.java
|
package jkind.solvers;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import jkind.JKindException;
public abstract class ProcessBasedSolver extends Solver {
protected static final String DONE = "@DONE";
protected Process process;
protected BufferedWriter toSolver;
protected BufferedReader fromSolver;
protected PrintWriter scratch;
protected ProcessBasedSolver(String scratchBase) {
this.scratch = getScratch(scratchBase);
ProcessBuilder processBuilder = new ProcessBuilder(getSolverCommand());
processBuilder.redirectErrorStream(true);
try {
process = processBuilder.start();
} catch (IOException e) {
throw new JKindException("Unable to start solver by executing: " + processBuilder.command().get(0), e);
}
addShutdownHook();
toSolver = new BufferedWriter(new OutputStreamWriter(process.getOutputStream()));
fromSolver = new BufferedReader(new InputStreamReader(process.getInputStream()));
}
private PrintWriter getScratch(String scratchBase) {
if (scratchBase == null) {
return null;
}
String filename = scratchBase + "." + getSolverExtension();
try {
return new PrintWriter(new FileOutputStream(filename), true);
} catch (FileNotFoundException e) {
throw new JKindException("Unable to open scratch file: " + filename, e);
}
}
private List<String> getSolverCommand() {
List<String> command = new ArrayList<>();
command.add(getSolverPath());
command.addAll(Arrays.asList(getSolverOptions()));
return command;
}
private String getSolverPath() {
String executable = getSolverExecutable();
String home = System.getenv(getSolverHomeVariable());
if (home != null) {
return new File(getBinDir(home), executable).toString();
}
return executable;
}
private static File getBinDir(String homeString) {
File home = new File(homeString);
File bin = new File(home, "bin");
if (bin.isDirectory()) {
return bin;
} else {
return home;
}
}
protected abstract String getSolverName();
protected abstract String getSolverExtension();
protected String getSolverExecutable() {
return getSolverName().toLowerCase();
}
protected String[] getSolverOptions() {
return new String[0];
}
protected String getSolverHomeVariable() {
return getSolverName().toUpperCase() + "_HOME";
}
private final Thread shutdownHook = new Thread("shutdown-hook") {
@Override
public void run() {
ProcessBasedSolver.this.stop();
}
};
private void addShutdownHook() {
Runtime.getRuntime().addShutdownHook(shutdownHook);
}
private void removeShutdownHook() {
try {
Runtime.getRuntime().removeShutdownHook(shutdownHook);
} catch (IllegalStateException e) {
// Ignore, we are already shutting down
}
}
@Override
public synchronized void stop() {
/**
* This must be synchronized since two threads (an Engine or a shutdown
* hook) may try to stop the solver at the same time
*/
if (process != null) {
process.destroy();
process = null;
}
if (scratch != null) {
scratch.close();
scratch = null;
}
removeShutdownHook();
}
public void scratch(String str) {
if (scratch != null) {
scratch.println(str);
}
}
@Override
public void comment(String str) {
scratch("; " + str);
}
}
| 3,543
| 23.273973
| 106
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/smtlib2/SmtLib2Lexer.java
|
// Generated from SmtLib2.g4 by ANTLR 4.4
package jkind.solvers.smtlib2;
import org.antlr.v4.runtime.Lexer;
import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.Token;
import org.antlr.v4.runtime.TokenStream;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.misc.*;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class SmtLib2Lexer extends Lexer {
static { RuntimeMetaData.checkVersion("4.4", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__26=1, T__25=2, T__24=3, T__23=4, T__22=5, T__21=6, T__20=7, T__19=8,
T__18=9, T__17=10, T__16=11, T__15=12, T__14=13, T__13=14, T__12=15, T__11=16,
T__10=17, T__9=18, T__8=19, T__7=20, T__6=21, T__5=22, T__4=23, T__3=24,
T__2=25, T__1=26, T__0=27, BOOL=28, INT=29, REAL=30, ID=31, DIV0=32, WS=33,
ERROR=34;
public static String[] modeNames = {
"DEFAULT_MODE"
};
public static final String[] tokenNames = {
"'\\u0000'", "'\\u0001'", "'\\u0002'", "'\\u0003'", "'\\u0004'", "'\\u0005'",
"'\\u0006'", "'\\u0007'", "'\b'", "'\t'", "'\n'", "'\\u000B'", "'\f'",
"'\r'", "'\\u000E'", "'\\u000F'", "'\\u0010'", "'\\u0011'", "'\\u0012'",
"'\\u0013'", "'\\u0014'", "'\\u0015'", "'\\u0016'", "'\\u0017'", "'\\u0018'",
"'\\u0019'", "'\\u001A'", "'\\u001B'", "'\\u001C'", "'\\u001D'", "'\\u001E'",
"'\\u001F'", "' '", "'!'", "'\"'"
};
public static final String[] ruleNames = {
"T__26", "T__25", "T__24", "T__23", "T__22", "T__21", "T__20", "T__19",
"T__18", "T__17", "T__16", "T__15", "T__14", "T__13", "T__12", "T__11",
"T__10", "T__9", "T__8", "T__7", "T__6", "T__5", "T__4", "T__3", "T__2",
"T__1", "T__0", "BOOL", "DIGIT", "SYMBOL", "INT", "REAL", "ID", "DIV0",
"WS", "ERROR"
};
public SmtLib2Lexer(CharStream input) {
super(input);
_interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
@Override
public String getGrammarFileName() { return "SmtLib2.g4"; }
@Override
public String[] getTokenNames() { return tokenNames; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public String[] getModeNames() { return modeNames; }
@Override
public ATN getATN() { return _ATN; }
public static final String _serializedATN =
"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\2$\u00e7\b\1\4\2\t"+
"\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+
"\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3"+
"\3\4\3\4\3\4\3\4\3\4\3\5\3\5\3\6\3\6\3\6\3\7\3\7\3\b\3\b\3\t\3\t\3\t\3"+
"\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13"+
"\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\3\r\3\16\3\16"+
"\3\16\3\16\3\17\3\17\3\17\3\17\3\20\3\20\3\20\3\21\3\21\3\22\3\22\3\23"+
"\3\23\3\24\3\24\3\24\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\27\3\27\3\27"+
"\3\27\3\30\3\30\3\31\3\31\3\31\3\31\3\32\3\32\3\33\3\33\3\33\3\33\3\34"+
"\3\34\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\5\35\u00bb\n\35\3\36"+
"\3\36\3\37\3\37\3 \6 \u00c2\n \r \16 \u00c3\3!\6!\u00c7\n!\r!\16!\u00c8"+
"\3!\3!\6!\u00cd\n!\r!\16!\u00ce\3\"\3\"\3\"\7\"\u00d4\n\"\f\"\16\"\u00d7"+
"\13\"\3\"\5\"\u00da\n\"\3#\3#\3#\3$\6$\u00e0\n$\r$\16$\u00e1\3$\3$\3%"+
"\3%\2\2&\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n\23\13\25\f\27\r\31\16\33\17"+
"\35\20\37\21!\22#\23%\24\'\25)\26+\27-\30/\31\61\32\63\33\65\34\67\35"+
"9\36;\2=\2?\37A C!E\"G#I$\3\2\5\3\2\62;\t\2##%\'))/\60Bac|\u0080\u0080"+
"\5\2\13\f\16\17\"\"\u00ec\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2"+
"\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2"+
"\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37\3"+
"\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2\2\2)\3\2\2\2\2+\3\2"+
"\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63\3\2\2\2\2\65\3\2\2\2\2\67"+
"\3\2\2\2\29\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2C\3\2\2\2\2E\3\2\2\2\2G\3\2"+
"\2\2\2I\3\2\2\2\3K\3\2\2\2\5M\3\2\2\2\7U\3\2\2\2\tZ\3\2\2\2\13\\\3\2\2"+
"\2\r_\3\2\2\2\17a\3\2\2\2\21c\3\2\2\2\23j\3\2\2\2\25n\3\2\2\2\27y\3\2"+
"\2\2\31~\3\2\2\2\33\u0084\3\2\2\2\35\u0088\3\2\2\2\37\u008c\3\2\2\2!\u008f"+
"\3\2\2\2#\u0091\3\2\2\2%\u0093\3\2\2\2\'\u0095\3\2\2\2)\u0098\3\2\2\2"+
"+\u009b\3\2\2\2-\u009f\3\2\2\2/\u00a3\3\2\2\2\61\u00a5\3\2\2\2\63\u00a9"+
"\3\2\2\2\65\u00ab\3\2\2\2\67\u00af\3\2\2\29\u00ba\3\2\2\2;\u00bc\3\2\2"+
"\2=\u00be\3\2\2\2?\u00c1\3\2\2\2A\u00c6\3\2\2\2C\u00d9\3\2\2\2E\u00db"+
"\3\2\2\2G\u00df\3\2\2\2I\u00e5\3\2\2\2KL\7\61\2\2L\4\3\2\2\2MN\7v\2\2"+
"NO\7q\2\2OP\7a\2\2PQ\7t\2\2QR\7g\2\2RS\7c\2\2ST\7n\2\2T\6\3\2\2\2UV\7"+
"D\2\2VW\7q\2\2WX\7q\2\2XY\7n\2\2Y\b\3\2\2\2Z[\7?\2\2[\n\3\2\2\2\\]\7>"+
"\2\2]^\7?\2\2^\f\3\2\2\2_`\7*\2\2`\16\3\2\2\2ab\7,\2\2b\20\3\2\2\2cd\7"+
"v\2\2de\7q\2\2ef\7a\2\2fg\7k\2\2gh\7p\2\2hi\7v\2\2i\22\3\2\2\2jk\7k\2"+
"\2kl\7v\2\2lm\7g\2\2m\24\3\2\2\2no\7f\2\2op\7g\2\2pq\7h\2\2qr\7k\2\2r"+
"s\7p\2\2st\7g\2\2tu\7/\2\2uv\7h\2\2vw\7w\2\2wx\7p\2\2x\26\3\2\2\2yz\7"+
"T\2\2z{\7g\2\2{|\7c\2\2|}\7n\2\2}\30\3\2\2\2~\177\7o\2\2\177\u0080\7q"+
"\2\2\u0080\u0081\7f\2\2\u0081\u0082\7g\2\2\u0082\u0083\7n\2\2\u0083\32"+
"\3\2\2\2\u0084\u0085\7K\2\2\u0085\u0086\7p\2\2\u0086\u0087\7v\2\2\u0087"+
"\34\3\2\2\2\u0088\u0089\7o\2\2\u0089\u008a\7q\2\2\u008a\u008b\7f\2\2\u008b"+
"\36\3\2\2\2\u008c\u008d\7@\2\2\u008d\u008e\7?\2\2\u008e \3\2\2\2\u008f"+
"\u0090\7~\2\2\u0090\"\3\2\2\2\u0091\u0092\7>\2\2\u0092$\3\2\2\2\u0093"+
"\u0094\7@\2\2\u0094&\3\2\2\2\u0095\u0096\7q\2\2\u0096\u0097\7t\2\2\u0097"+
"(\3\2\2\2\u0098\u0099\7?\2\2\u0099\u009a\7@\2\2\u009a*\3\2\2\2\u009b\u009c"+
"\7n\2\2\u009c\u009d\7g\2\2\u009d\u009e\7v\2\2\u009e,\3\2\2\2\u009f\u00a0"+
"\7f\2\2\u00a0\u00a1\7k\2\2\u00a1\u00a2\7x\2\2\u00a2.\3\2\2\2\u00a3\u00a4"+
"\7+\2\2\u00a4\60\3\2\2\2\u00a5\u00a6\7c\2\2\u00a6\u00a7\7p\2\2\u00a7\u00a8"+
"\7f\2\2\u00a8\62\3\2\2\2\u00a9\u00aa\7-\2\2\u00aa\64\3\2\2\2\u00ab\u00ac"+
"\7p\2\2\u00ac\u00ad\7q\2\2\u00ad\u00ae\7v\2\2\u00ae\66\3\2\2\2\u00af\u00b0"+
"\7/\2\2\u00b08\3\2\2\2\u00b1\u00b2\7v\2\2\u00b2\u00b3\7t\2\2\u00b3\u00b4"+
"\7w\2\2\u00b4\u00bb\7g\2\2\u00b5\u00b6\7h\2\2\u00b6\u00b7\7c\2\2\u00b7"+
"\u00b8\7n\2\2\u00b8\u00b9\7u\2\2\u00b9\u00bb\7g\2\2\u00ba\u00b1\3\2\2"+
"\2\u00ba\u00b5\3\2\2\2\u00bb:\3\2\2\2\u00bc\u00bd\t\2\2\2\u00bd<\3\2\2"+
"\2\u00be\u00bf\t\3\2\2\u00bf>\3\2\2\2\u00c0\u00c2\5;\36\2\u00c1\u00c0"+
"\3\2\2\2\u00c2\u00c3\3\2\2\2\u00c3\u00c1\3\2\2\2\u00c3\u00c4\3\2\2\2\u00c4"+
"@\3\2\2\2\u00c5\u00c7\5;\36\2\u00c6\u00c5\3\2\2\2\u00c7\u00c8\3\2\2\2"+
"\u00c8\u00c6\3\2\2\2\u00c8\u00c9\3\2\2\2\u00c9\u00ca\3\2\2\2\u00ca\u00cc"+
"\7\60\2\2\u00cb\u00cd\5;\36\2\u00cc\u00cb\3\2\2\2\u00cd\u00ce\3\2\2\2"+
"\u00ce\u00cc\3\2\2\2\u00ce\u00cf\3\2\2\2\u00cfB\3\2\2\2\u00d0\u00d5\5"+
"=\37\2\u00d1\u00d4\5=\37\2\u00d2\u00d4\5;\36\2\u00d3\u00d1\3\2\2\2\u00d3"+
"\u00d2\3\2\2\2\u00d4\u00d7\3\2\2\2\u00d5\u00d3\3\2\2\2\u00d5\u00d6\3\2"+
"\2\2\u00d6\u00da\3\2\2\2\u00d7\u00d5\3\2\2\2\u00d8\u00da\5E#\2\u00d9\u00d0"+
"\3\2\2\2\u00d9\u00d8\3\2\2\2\u00daD\3\2\2\2\u00db\u00dc\7\61\2\2\u00dc"+
"\u00dd\7\62\2\2\u00ddF\3\2\2\2\u00de\u00e0\t\4\2\2\u00df\u00de\3\2\2\2"+
"\u00e0\u00e1\3\2\2\2\u00e1\u00df\3\2\2\2\u00e1\u00e2\3\2\2\2\u00e2\u00e3"+
"\3\2\2\2\u00e3\u00e4\b$\2\2\u00e4H\3\2\2\2\u00e5\u00e6\13\2\2\2\u00e6"+
"J\3\2\2\2\13\2\u00ba\u00c3\u00c8\u00ce\u00d3\u00d5\u00d9\u00e1\3\b\2\2";
public static final ATN _ATN =
new ATNDeserializer().deserialize(_serializedATN.toCharArray());
static {
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
}
}
}
| 8,176
| 54.25
| 81
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/smtlib2/SmtLib2Parser.java
|
// Generated from SmtLib2.g4 by ANTLR 4.4
package jkind.solvers.smtlib2;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class SmtLib2Parser extends Parser {
static { RuntimeMetaData.checkVersion("4.4", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__26=1, T__25=2, T__24=3, T__23=4, T__22=5, T__21=6, T__20=7, T__19=8,
T__18=9, T__17=10, T__16=11, T__15=12, T__14=13, T__13=14, T__12=15, T__11=16,
T__10=17, T__9=18, T__8=19, T__7=20, T__6=21, T__5=22, T__4=23, T__3=24,
T__2=25, T__1=26, T__0=27, BOOL=28, INT=29, REAL=30, ID=31, DIV0=32, WS=33,
ERROR=34;
public static final String[] tokenNames = {
"<INVALID>", "'/'", "'to_real'", "'Bool'", "'='", "'<='", "'('", "'*'",
"'to_int'", "'ite'", "'define-fun'", "'Real'", "'model'", "'Int'", "'mod'",
"'>='", "'|'", "'<'", "'>'", "'or'", "'=>'", "'let'", "'div'", "')'",
"'and'", "'+'", "'not'", "'-'", "BOOL", "INT", "REAL", "ID", "'/0'", "WS",
"ERROR"
};
public static final int
RULE_model = 0, RULE_define = 1, RULE_arg = 2, RULE_type = 3, RULE_body = 4,
RULE_binding = 5, RULE_fn = 6, RULE_symbol = 7, RULE_id = 8, RULE_qid = 9;
public static final String[] ruleNames = {
"model", "define", "arg", "type", "body", "binding", "fn", "symbol", "id",
"qid"
};
@Override
public String getGrammarFileName() { return "SmtLib2.g4"; }
@Override
public String[] getTokenNames() { return tokenNames; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public SmtLib2Parser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class ModelContext extends ParserRuleContext {
public DefineContext define(int i) {
return getRuleContext(DefineContext.class,i);
}
public List<DefineContext> define() {
return getRuleContexts(DefineContext.class);
}
public TerminalNode EOF() { return getToken(SmtLib2Parser.EOF, 0); }
public ModelContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_model; }
}
public final ModelContext model() throws RecognitionException {
ModelContext _localctx = new ModelContext(_ctx, getState());
enterRule(_localctx, 0, RULE_model);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(20); match(T__21);
setState(22);
_la = _input.LA(1);
if (_la==T__15) {
{
setState(21); match(T__15);
}
}
setState(27);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__21) {
{
{
setState(24); define();
}
}
setState(29);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(30); match(T__4);
setState(31); match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DefineContext extends ParserRuleContext {
public ArgContext arg(int i) {
return getRuleContext(ArgContext.class,i);
}
public IdContext id() {
return getRuleContext(IdContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public BodyContext body() {
return getRuleContext(BodyContext.class,0);
}
public List<ArgContext> arg() {
return getRuleContexts(ArgContext.class);
}
public DefineContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_define; }
}
public final DefineContext define() throws RecognitionException {
DefineContext _localctx = new DefineContext(_ctx, getState());
enterRule(_localctx, 2, RULE_define);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(33); match(T__21);
setState(34); match(T__17);
setState(35); id();
setState(36); match(T__21);
setState(40);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__21) {
{
{
setState(37); arg();
}
}
setState(42);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(43); match(T__4);
setState(44); type();
setState(45); body();
setState(46); match(T__4);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArgContext extends ParserRuleContext {
public IdContext id() {
return getRuleContext(IdContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public ArgContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arg; }
}
public final ArgContext arg() throws RecognitionException {
ArgContext _localctx = new ArgContext(_ctx, getState());
enterRule(_localctx, 4, RULE_arg);
try {
enterOuterAlt(_localctx, 1);
{
setState(48); match(T__21);
setState(49); id();
setState(50); type();
setState(51); match(T__4);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeContext extends ParserRuleContext {
public TypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_type; }
}
public final TypeContext type() throws RecognitionException {
TypeContext _localctx = new TypeContext(_ctx, getState());
enterRule(_localctx, 6, RULE_type);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(53);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__24) | (1L << T__16) | (1L << T__14))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BodyContext extends ParserRuleContext {
public BodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_body; }
public BodyContext() { }
public void copyFrom(BodyContext ctx) {
super.copyFrom(ctx);
}
}
public static class LetBodyContext extends BodyContext {
public List<BindingContext> binding() {
return getRuleContexts(BindingContext.class);
}
public BodyContext body() {
return getRuleContext(BodyContext.class,0);
}
public BindingContext binding(int i) {
return getRuleContext(BindingContext.class,i);
}
public LetBodyContext(BodyContext ctx) { copyFrom(ctx); }
}
public static class ConsBodyContext extends BodyContext {
public BodyContext body(int i) {
return getRuleContext(BodyContext.class,i);
}
public FnContext fn() {
return getRuleContext(FnContext.class,0);
}
public List<BodyContext> body() {
return getRuleContexts(BodyContext.class);
}
public ConsBodyContext(BodyContext ctx) { copyFrom(ctx); }
}
public static class SymbolBodyContext extends BodyContext {
public SymbolContext symbol() {
return getRuleContext(SymbolContext.class,0);
}
public SymbolBodyContext(BodyContext ctx) { copyFrom(ctx); }
}
public final BodyContext body() throws RecognitionException {
BodyContext _localctx = new BodyContext(_ctx, getState());
enterRule(_localctx, 8, RULE_body);
int _la;
try {
setState(79);
switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
case 1:
_localctx = new SymbolBodyContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(55); symbol();
}
break;
case 2:
_localctx = new ConsBodyContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(56); match(T__21);
setState(57); fn();
setState(61);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__21) | (1L << T__11) | (1L << BOOL) | (1L << INT) | (1L << REAL) | (1L << ID))) != 0)) {
{
{
setState(58); body();
}
}
setState(63);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(64); match(T__4);
}
break;
case 3:
_localctx = new LetBodyContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(66); match(T__21);
setState(67); match(T__6);
setState(68); match(T__21);
setState(72);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__21) {
{
{
setState(69); binding();
}
}
setState(74);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(75); match(T__4);
setState(76); body();
setState(77); match(T__4);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BindingContext extends ParserRuleContext {
public IdContext id() {
return getRuleContext(IdContext.class,0);
}
public BodyContext body() {
return getRuleContext(BodyContext.class,0);
}
public BindingContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_binding; }
}
public final BindingContext binding() throws RecognitionException {
BindingContext _localctx = new BindingContext(_ctx, getState());
enterRule(_localctx, 10, RULE_binding);
try {
enterOuterAlt(_localctx, 1);
{
setState(81); match(T__21);
setState(82); id();
setState(83); body();
setState(84); match(T__4);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FnContext extends ParserRuleContext {
public TerminalNode DIV0() { return getToken(SmtLib2Parser.DIV0, 0); }
public FnContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fn; }
}
public final FnContext fn() throws RecognitionException {
FnContext _localctx = new FnContext(_ctx, getState());
enterRule(_localctx, 12, RULE_fn);
try {
setState(106);
switch (_input.LA(1)) {
case T__23:
enterOuterAlt(_localctx, 1);
{
setState(86); match(T__23);
}
break;
case T__2:
enterOuterAlt(_localctx, 2);
{
setState(87); match(T__2);
}
break;
case T__20:
enterOuterAlt(_localctx, 3);
{
setState(88); match(T__20);
}
break;
case T__0:
enterOuterAlt(_localctx, 4);
{
setState(89); match(T__0);
}
break;
case T__26:
enterOuterAlt(_localctx, 5);
{
setState(90); match(T__26);
}
break;
case DIV0:
enterOuterAlt(_localctx, 6);
{
setState(91); match(DIV0);
}
break;
case T__5:
enterOuterAlt(_localctx, 7);
{
setState(92); match(T__5);
}
break;
case T__13:
enterOuterAlt(_localctx, 8);
{
setState(93); match(T__13);
}
break;
case T__3:
enterOuterAlt(_localctx, 9);
{
setState(94); match(T__3);
}
break;
case T__8:
enterOuterAlt(_localctx, 10);
{
setState(95); match(T__8);
}
break;
case T__1:
enterOuterAlt(_localctx, 11);
{
setState(96); match(T__1);
}
break;
case T__7:
enterOuterAlt(_localctx, 12);
{
setState(97); match(T__7);
}
break;
case T__18:
enterOuterAlt(_localctx, 13);
{
setState(98); match(T__18);
}
break;
case T__21:
case T__11:
case T__4:
case BOOL:
case INT:
case REAL:
case ID:
enterOuterAlt(_localctx, 14);
{
}
break;
case T__12:
enterOuterAlt(_localctx, 15);
{
setState(100); match(T__12);
}
break;
case T__22:
enterOuterAlt(_localctx, 16);
{
setState(101); match(T__22);
}
break;
case T__10:
enterOuterAlt(_localctx, 17);
{
setState(102); match(T__10);
}
break;
case T__9:
enterOuterAlt(_localctx, 18);
{
setState(103); match(T__9);
}
break;
case T__25:
enterOuterAlt(_localctx, 19);
{
setState(104); match(T__25);
}
break;
case T__19:
enterOuterAlt(_localctx, 20);
{
setState(105); match(T__19);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SymbolContext extends ParserRuleContext {
public TerminalNode BOOL() { return getToken(SmtLib2Parser.BOOL, 0); }
public TerminalNode REAL() { return getToken(SmtLib2Parser.REAL, 0); }
public IdContext id() {
return getRuleContext(IdContext.class,0);
}
public TerminalNode INT() { return getToken(SmtLib2Parser.INT, 0); }
public SymbolContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_symbol; }
}
public final SymbolContext symbol() throws RecognitionException {
SymbolContext _localctx = new SymbolContext(_ctx, getState());
enterRule(_localctx, 14, RULE_symbol);
try {
setState(112);
switch (_input.LA(1)) {
case T__11:
case ID:
enterOuterAlt(_localctx, 1);
{
setState(108); id();
}
break;
case BOOL:
enterOuterAlt(_localctx, 2);
{
setState(109); match(BOOL);
}
break;
case INT:
enterOuterAlt(_localctx, 3);
{
setState(110); match(INT);
}
break;
case REAL:
enterOuterAlt(_localctx, 4);
{
setState(111); match(REAL);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IdContext extends ParserRuleContext {
public TerminalNode ID() { return getToken(SmtLib2Parser.ID, 0); }
public QidContext qid() {
return getRuleContext(QidContext.class,0);
}
public IdContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_id; }
}
public final IdContext id() throws RecognitionException {
IdContext _localctx = new IdContext(_ctx, getState());
enterRule(_localctx, 16, RULE_id);
try {
setState(116);
switch (_input.LA(1)) {
case T__11:
enterOuterAlt(_localctx, 1);
{
setState(114); qid();
}
break;
case ID:
enterOuterAlt(_localctx, 2);
{
setState(115); match(ID);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QidContext extends ParserRuleContext {
public TerminalNode ID() { return getToken(SmtLib2Parser.ID, 0); }
public QidContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qid; }
}
public final QidContext qid() throws RecognitionException {
QidContext _localctx = new QidContext(_ctx, getState());
enterRule(_localctx, 18, RULE_qid);
try {
enterOuterAlt(_localctx, 1);
{
setState(118); match(T__11);
setState(119); match(ID);
setState(120); match(T__11);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static final String _serializedATN =
"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3$}\4\2\t\2\4\3\t\3"+
"\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\3\2"+
"\3\2\5\2\31\n\2\3\2\7\2\34\n\2\f\2\16\2\37\13\2\3\2\3\2\3\2\3\3\3\3\3"+
"\3\3\3\3\3\7\3)\n\3\f\3\16\3,\13\3\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4"+
"\3\4\3\5\3\5\3\6\3\6\3\6\3\6\7\6>\n\6\f\6\16\6A\13\6\3\6\3\6\3\6\3\6\3"+
"\6\3\6\7\6I\n\6\f\6\16\6L\13\6\3\6\3\6\3\6\3\6\5\6R\n\6\3\7\3\7\3\7\3"+
"\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b"+
"\3\b\3\b\3\b\3\b\5\bm\n\b\3\t\3\t\3\t\3\t\5\ts\n\t\3\n\3\n\5\nw\n\n\3"+
"\13\3\13\3\13\3\13\3\13\2\2\f\2\4\6\b\n\f\16\20\22\24\2\3\5\2\5\5\r\r"+
"\17\17\u0090\2\26\3\2\2\2\4#\3\2\2\2\6\62\3\2\2\2\b\67\3\2\2\2\nQ\3\2"+
"\2\2\fS\3\2\2\2\16l\3\2\2\2\20r\3\2\2\2\22v\3\2\2\2\24x\3\2\2\2\26\30"+
"\7\b\2\2\27\31\7\16\2\2\30\27\3\2\2\2\30\31\3\2\2\2\31\35\3\2\2\2\32\34"+
"\5\4\3\2\33\32\3\2\2\2\34\37\3\2\2\2\35\33\3\2\2\2\35\36\3\2\2\2\36 \3"+
"\2\2\2\37\35\3\2\2\2 !\7\31\2\2!\"\7\2\2\3\"\3\3\2\2\2#$\7\b\2\2$%\7\f"+
"\2\2%&\5\22\n\2&*\7\b\2\2\')\5\6\4\2(\'\3\2\2\2),\3\2\2\2*(\3\2\2\2*+"+
"\3\2\2\2+-\3\2\2\2,*\3\2\2\2-.\7\31\2\2./\5\b\5\2/\60\5\n\6\2\60\61\7"+
"\31\2\2\61\5\3\2\2\2\62\63\7\b\2\2\63\64\5\22\n\2\64\65\5\b\5\2\65\66"+
"\7\31\2\2\66\7\3\2\2\2\678\t\2\2\28\t\3\2\2\29R\5\20\t\2:;\7\b\2\2;?\5"+
"\16\b\2<>\5\n\6\2=<\3\2\2\2>A\3\2\2\2?=\3\2\2\2?@\3\2\2\2@B\3\2\2\2A?"+
"\3\2\2\2BC\7\31\2\2CR\3\2\2\2DE\7\b\2\2EF\7\27\2\2FJ\7\b\2\2GI\5\f\7\2"+
"HG\3\2\2\2IL\3\2\2\2JH\3\2\2\2JK\3\2\2\2KM\3\2\2\2LJ\3\2\2\2MN\7\31\2"+
"\2NO\5\n\6\2OP\7\31\2\2PR\3\2\2\2Q9\3\2\2\2Q:\3\2\2\2QD\3\2\2\2R\13\3"+
"\2\2\2ST\7\b\2\2TU\5\22\n\2UV\5\n\6\2VW\7\31\2\2W\r\3\2\2\2Xm\7\6\2\2"+
"Ym\7\33\2\2Zm\7\t\2\2[m\7\35\2\2\\m\7\3\2\2]m\7\"\2\2^m\7\30\2\2_m\7\20"+
"\2\2`m\7\32\2\2am\7\25\2\2bm\7\34\2\2cm\7\26\2\2dm\7\13\2\2em\3\2\2\2"+
"fm\7\21\2\2gm\7\7\2\2hm\7\23\2\2im\7\24\2\2jm\7\4\2\2km\7\n\2\2lX\3\2"+
"\2\2lY\3\2\2\2lZ\3\2\2\2l[\3\2\2\2l\\\3\2\2\2l]\3\2\2\2l^\3\2\2\2l_\3"+
"\2\2\2l`\3\2\2\2la\3\2\2\2lb\3\2\2\2lc\3\2\2\2ld\3\2\2\2le\3\2\2\2lf\3"+
"\2\2\2lg\3\2\2\2lh\3\2\2\2li\3\2\2\2lj\3\2\2\2lk\3\2\2\2m\17\3\2\2\2n"+
"s\5\22\n\2os\7\36\2\2ps\7\37\2\2qs\7 \2\2rn\3\2\2\2ro\3\2\2\2rp\3\2\2"+
"\2rq\3\2\2\2s\21\3\2\2\2tw\5\24\13\2uw\7!\2\2vt\3\2\2\2vu\3\2\2\2w\23"+
"\3\2\2\2xy\7\22\2\2yz\7!\2\2z{\7\22\2\2{\25\3\2\2\2\13\30\35*?JQlrv";
public static final ATN _ATN =
new ATNDeserializer().deserialize(_serializedATN.toCharArray());
static {
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
}
}
}
| 19,581
| 25.861454
| 149
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/smtlib2/ModelExtractor.java
|
package jkind.solvers.smtlib2;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.antlr.v4.runtime.tree.ParseTree;
import org.antlr.v4.runtime.tree.TerminalNode;
import jkind.lustre.Function;
import jkind.lustre.Type;
import jkind.sexp.Cons;
import jkind.sexp.Sexp;
import jkind.sexp.Symbol;
import jkind.solvers.smtlib2.SmtLib2Parser.ArgContext;
import jkind.solvers.smtlib2.SmtLib2Parser.BodyContext;
import jkind.solvers.smtlib2.SmtLib2Parser.ConsBodyContext;
import jkind.solvers.smtlib2.SmtLib2Parser.DefineContext;
import jkind.solvers.smtlib2.SmtLib2Parser.IdContext;
import jkind.solvers.smtlib2.SmtLib2Parser.ModelContext;
import jkind.solvers.smtlib2.SmtLib2Parser.SymbolBodyContext;
import jkind.solvers.smtlib2.SmtLib2Parser.TypeContext;
public class ModelExtractor {
public static final String TRANSITION_RELATION_FN_NAME = "T";
public static SmtLib2Model getModel(ModelContext ctx, Map<String, Type> varTypes, List<Function> functions) {
SmtLib2Model model = new SmtLib2Model(varTypes, functions);
for (DefineContext defineCtx : ctx.define()) {
if(!isTransitionRelation(defineCtx)) {
walkDefine(defineCtx, model);
}
}
return model;
}
private static boolean isTransitionRelation(DefineContext defineCtx) {
ParseTree x = defineCtx.id().children.get(0);
if(x instanceof TerminalNode) {
TerminalNode tn = (TerminalNode) x;
return (tn.getText().equals(TRANSITION_RELATION_FN_NAME));
}
return false;
}
public static void walkDefine(DefineContext ctx, SmtLib2Model model) {
String var = getId(ctx.id());
Sexp args = getArgs(ctx.arg());
Sexp body = sexp(ctx.body());
if (args != null) {
body = new Cons("lambda", args, body);
}
model.addValue(var, body);
}
private static Sexp getArgs(List<ArgContext> argContexts) {
if (argContexts.size() == 0) {
return null;
}
List<Sexp> cons = new ArrayList<>();
for (ArgContext argCtx : argContexts) {
String id = getId(argCtx.id());
String type = getType(argCtx.type());
cons.add(new Cons(id, new Symbol(type)));
}
return new Cons(cons);
}
private static String getId(IdContext id) {
return Quoting.unquote(id.getText());
}
private static String getType(TypeContext id) {
return Quoting.unquote(id.getText());
}
private static Sexp sexp(BodyContext ctx) {
if (ctx instanceof SymbolBodyContext) {
SymbolBodyContext sbc = (SymbolBodyContext) ctx;
return new Symbol(parse(sbc.symbol().getText()));
} else if (ctx instanceof ConsBodyContext) {
ConsBodyContext cbc = (ConsBodyContext) ctx;
List<Sexp> args = new ArrayList<>();
for (BodyContext sub : cbc.body()) {
args.add(sexp(sub));
}
return new Cons(cbc.fn().getText(), args);
} else {
throw new IllegalArgumentException();
}
}
private static String parse(String string) {
if (string.contains(".")) {
BigDecimal d = new BigDecimal(string);
BigInteger numerator = d.unscaledValue();
BigInteger denominator = BigDecimal.TEN.pow(d.scale()).toBigInteger();
BigInteger gcd = numerator.gcd(denominator);
numerator = numerator.divide(gcd);
denominator = denominator.divide(gcd);
if (denominator.equals(BigInteger.ONE)) {
return numerator.toString();
} else {
return numerator + "/" + denominator;
}
} else {
return string;
}
}
}
| 3,400
| 28.068376
| 110
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/smtlib2/SolverOutOfMemoryException.java
|
package jkind.solvers.smtlib2;
public class SolverOutOfMemoryException extends RuntimeException {
private static final long serialVersionUID = 1L;
}
| 151
| 24.333333
| 66
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/smtlib2/SexpEvaluator.java
|
package jkind.solvers.smtlib2;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import jkind.lustre.BinaryOp;
import jkind.lustre.UnaryOp;
import jkind.lustre.values.BooleanValue;
import jkind.lustre.values.IntegerValue;
import jkind.lustre.values.RealValue;
import jkind.lustre.values.Value;
import jkind.sexp.Cons;
import jkind.sexp.Sexp;
import jkind.sexp.Symbol;
import jkind.solvers.Model;
import jkind.util.BigFraction;
import jkind.util.Util;
public class SexpEvaluator {
private final Function<String, Value> lookupSymbol;
public SexpEvaluator(Function<String, Value> lookupSymbol) {
this.lookupSymbol = lookupSymbol;
}
public SexpEvaluator(Model model) {
this.lookupSymbol = model::getValue;
}
public Value eval(Sexp sexp) {
if (sexp instanceof Symbol) {
return evalSymbol(((Symbol) sexp).str);
} else if (sexp instanceof Cons) {
return evalCons((Cons) sexp);
} else {
throw new IllegalArgumentException();
}
}
private Value evalSymbol(String sym) {
if (sym.equals("true")) {
return BooleanValue.TRUE;
} else if (sym.equals("false")) {
return BooleanValue.FALSE;
} else if (!Character.isDigit(sym.charAt(0)) && sym.charAt(0) != '-') {
return lookupSymbol.apply(sym);
} else if (sym.contains("/")) {
return Util.parseValue("real", sym);
} else {
return Util.parseValue("int", sym);
}
}
private Value evalCons(Cons sexp) {
String fn = ((Symbol) sexp.head).str;
if (fn.equals("ite")) {
return isTrue(eval(sexp.args.get(0))) ? eval(sexp.args.get(1)) : eval(sexp.args.get(2));
} else if (fn.equals("and")) {
for (Sexp arg : sexp.args) {
if (!isTrue(eval(arg))) {
return BooleanValue.FALSE;
}
}
return BooleanValue.TRUE;
} else if (fn.equals("or")) {
for (Sexp arg : sexp.args) {
if (isTrue(eval(arg))) {
return BooleanValue.TRUE;
}
}
return BooleanValue.FALSE;
}
List<Value> args = new ArrayList<>();
for (Sexp arg : sexp.args) {
args.add(eval(arg));
}
return evalFunction(fn, args);
}
private boolean isTrue(Value v) {
return v == BooleanValue.TRUE;
}
private Value evalFunction(String fn, List<Value> args) {
switch (fn) {
case "=":
return checkEquality(args.get(0), args.get(1));
case "-": {
if (args.size() == 1) {
return args.get(0).applyUnaryOp(UnaryOp.NEGATIVE);
} else {
return applyBinaryOp(args.get(0), BinaryOp.MINUS, args.get(1));
}
}
case "/":
return applyBinaryOp(args.get(0), BinaryOp.DIVIDE, args.get(1));
case "<=":
return applyBinaryOp(args.get(0), BinaryOp.LESSEQUAL, args.get(1));
case ">=":
return applyBinaryOp(args.get(0), BinaryOp.GREATEREQUAL, args.get(1));
case "<":
return applyBinaryOp(args.get(0), BinaryOp.LESS, args.get(1));
case ">":
return applyBinaryOp(args.get(0), BinaryOp.GREATER, args.get(1));
case "not":
return args.get(0).applyUnaryOp(UnaryOp.NOT);
default:
throw new IllegalArgumentException();
}
}
private Value checkEquality(Value left, Value right) {
if (left instanceof RealValue && right instanceof IntegerValue) {
right = promote(right);
} else if (left instanceof IntegerValue && right instanceof RealValue) {
left = promote(left);
}
return BooleanValue.fromBoolean(left.equals(right));
}
private Value applyBinaryOp(Value left, BinaryOp op, Value right) {
if (op == BinaryOp.DIVIDE) {
left = promote(left);
right = promote(right);
} else if (left instanceof RealValue && right instanceof IntegerValue) {
right = promote(right);
} else if (left instanceof IntegerValue && right instanceof RealValue) {
left = promote(left);
}
return left.applyBinaryOp(op, right);
}
private RealValue promote(Value value) {
if (value instanceof IntegerValue) {
IntegerValue iv = (IntegerValue) value;
return new RealValue(new BigFraction(iv.value));
} else if (value instanceof RealValue) {
return (RealValue) value;
} else {
throw new IllegalArgumentException();
}
}
}
| 4,017
| 26.710345
| 91
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/smtlib2/SmtLib2Solver.java
|
package jkind.solvers.smtlib2;
import static java.util.stream.Collectors.toList;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.antlr.v4.runtime.ANTLRInputStream;
import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.RecognitionException;
import jkind.JKindException;
import jkind.lustre.Function;
import jkind.lustre.NamedType;
import jkind.lustre.Type;
import jkind.lustre.VarDecl;
import jkind.sexp.Cons;
import jkind.sexp.Sexp;
import jkind.sexp.Symbol;
import jkind.solvers.Model;
import jkind.solvers.ProcessBasedSolver;
import jkind.solvers.Result;
import jkind.solvers.SatResult;
import jkind.solvers.SolverParserErrorListener;
import jkind.solvers.UnknownResult;
import jkind.solvers.UnsatResult;
import jkind.solvers.smtlib2.SmtLib2Parser.ModelContext;
import jkind.translation.Relation;
import jkind.util.SexpUtil;
import jkind.util.Util;
public abstract class SmtLib2Solver extends ProcessBasedSolver {
public SmtLib2Solver(String scratchBase) {
super(scratchBase);
}
@Override
public void assertSexp(Sexp sexp) {
send(new Cons("assert", sexp));
}
protected void send(Sexp sexp) {
send(Quoting.quoteSexp(sexp).toString());
}
protected void send(String str) {
scratch(str);
try {
toSolver.append(str);
toSolver.newLine();
toSolver.flush();
} catch (IOException e) {
throw new JKindException(
"Unable to write to " + getSolverName() + ", " + "probably due to internal JKind error", e);
}
}
public Symbol type(Type type) {
return new Symbol(Util.capitalize(Util.getName(type)));
}
public void declFun(String ef, NamedType t1, NamedType t2) {
send(new Cons("declare-fun", new Symbol(ef), new Symbol("(" + type(t1) + ")"), type(t2)));
}
@Override
public void define(VarDecl decl) {
varTypes.put(decl.id, decl.type);
send(new Cons("declare-fun", new Symbol(decl.id), new Symbol("()"), type(decl.type)));
}
@Override
public void declare(Function function) {
functions.add(function);
Symbol name = new Symbol(SexpUtil.encodeFunction(function.id));
List<Sexp> inputTypes = function.inputs.stream().map(vd -> type(vd.type)).collect(toList());
Sexp inputTypesDecl = inputTypes.isEmpty() ? new Symbol("()") : new Cons(inputTypes);
Symbol outputType = type(function.outputs.get(0).type);
send(new Cons("declare-fun", name, inputTypesDecl, outputType));
}
@Override
public void define(Relation relation) {
send(new Cons("define-fun", new Symbol(relation.getName()), inputs(relation.getInputs()), type(NamedType.BOOL),
relation.getBody()));
}
private Sexp inputs(List<VarDecl> inputs) {
List<Sexp> args = new ArrayList<>();
for (VarDecl vd : inputs) {
args.add(new Cons(vd.id, type(vd.type)));
}
return new Cons(args);
}
@Override
public Result query(Sexp sexp) {
Result result = null;
push();
assertSexp(new Cons("not", sexp));
send("(check-sat)");
String status = readFromSolver();
if (isSat(status)) {
send("(get-model)");
result = new SatResult(parseModel(readFromSolver()));
} else if (isUnsat(status)) {
result = new UnsatResult();
} else {
throw new IllegalArgumentException("Unknown result: " + result);
}
pop();
return result;
}
@Override
protected Result quickCheckSat(List<Symbol> activationLiterals) {
push();
for (Symbol actLit : activationLiterals) {
String name = "_" + actLit.str;
assertSexp(new Cons("!", actLit, new Symbol(":named"), new Symbol(name)));
}
send("(check-sat)");
String status = readFromSolver();
Result result;
if (isSat(status)) {
result = new SatResult();
} else if (isUnsat(status)) {
result = new UnsatResult(getUnsatCore(activationLiterals));
} else {
result = new UnknownResult();
}
pop();
return result;
}
protected abstract List<Symbol> getUnsatCore(List<Symbol> activationLiterals);
protected boolean isSat(String output) {
// Only check prefix, Z3 outputs content after 'sat' for max-sat style
// queries
return output.trim().startsWith("sat");
}
protected boolean isUnsat(String output) {
return output.trim().equals("unsat");
}
protected String readFromSolver() {
send("(echo \"" + DONE + "\")");
try {
String line;
StringBuilder content = new StringBuilder();
while (true) {
line = fromSolver.readLine();
comment(getSolverName() + ": " + line);
if (line == null) {
throw new JKindException(getSolverName() + " terminated unexpectedly");
} else if (isDone(line)) {
break;
} else if (line.contains("model is not available")) {
flushSolver();
return null;
} else if (line.contains(" |-> ")) {
// Ignore Z3 optimization information
} else if (line.contains("out of memory")) {
throw new SolverOutOfMemoryException();
} else if (line.contains("error \"") || line.contains("Error:")) {
// Flush the output since errors span multiple lines
flushSolver();
throw new JKindException(getSolverName() + " error (see scratch file for details)");
} else {
content.append(line);
content.append("\n");
}
}
return content.toString();
} catch (RecognitionException e) {
throw new JKindException("Error parsing " + getSolverName() + " output", e);
} catch (IOException e) {
throw new JKindException("Unable to read from " + getSolverName(), e);
}
}
protected void flushSolver() throws IOException {
String line;
while ((line = fromSolver.readLine()) != null) {
comment(getSolverName() + ": " + line);
if (isDone(line)) {
return;
}
}
}
protected boolean isDone(String line) {
return line.contains(DONE);
}
protected Model parseModel(String modelStr) {
return parseSmtLib2Model(modelStr, varTypes, functions);
}
public static SmtLib2Model parseSmtLib2Model(String modelStr, Map<String, Type> varTypes,
List<Function> functions) {
CharStream stream = new ANTLRInputStream(modelStr);
SmtLib2Lexer lexer = new SmtLib2Lexer(stream);
CommonTokenStream tokens = new CommonTokenStream(lexer);
SmtLib2Parser parser = new SmtLib2Parser(tokens);
parser.removeErrorListeners();
parser.addErrorListener(new SolverParserErrorListener());
ModelContext ctx = parser.model();
if (parser.getNumberOfSyntaxErrors() > 0) {
throw new JKindException("Error parsing solver output: " + modelStr);
}
return ModelExtractor.getModel(ctx, varTypes, functions);
}
@Override
public void push() {
send("(push 1)");
}
@Override
public void pop() {
send("(pop 1)");
}
@Override
public String getSolverExtension() {
return "smt2";
}
}
| 6,669
| 26.44856
| 113
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/smtlib2/Quoting.java
|
package jkind.solvers.smtlib2;
import java.util.ArrayList;
import java.util.List;
import jkind.sexp.Cons;
import jkind.sexp.Sexp;
import jkind.sexp.Symbol;
public class Quoting {
public static boolean needsQuotes(Symbol symb) {
return symb.str.contains("[");
}
public static Symbol quoteSymbol(Symbol symb) {
return new Symbol("|" + symb.str + "|");
}
public static Sexp quoteSexp(Sexp sexp) {
if (sexp instanceof Cons) {
Cons cons = (Cons) sexp;
return new Cons(quoteSexp(cons.head), quoteSexps(cons.args));
} else if (sexp instanceof Symbol) {
Symbol symb = (Symbol) sexp;
if (needsQuotes(symb)) {
return quoteSymbol(symb);
} else {
return symb;
}
} else {
throw new IllegalArgumentException();
}
}
private static List<Sexp> quoteSexps(List<? extends Sexp> sexps) {
List<Sexp> result = new ArrayList<>();
for (Sexp sexp : sexps) {
result.add(quoteSexp(sexp));
}
return result;
}
public static String unquote(String text) {
if (text.startsWith("|")) {
return text.substring(1, text.length() - 1);
} else {
return text;
}
}
}
| 1,108
| 20.326923
| 67
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/smtlib2/SmtLib2Model.java
|
package jkind.solvers.smtlib2;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import jkind.lustre.Function;
import jkind.lustre.Type;
import jkind.lustre.values.Value;
import jkind.sexp.Cons;
import jkind.sexp.Sexp;
import jkind.sexp.Symbol;
import jkind.solvers.Model;
import jkind.util.Util;
public class SmtLib2Model extends Model {
private final Map<String, Sexp> values = new HashMap<>();
public SmtLib2Model(Map<String, Type> varTypes, List<Function> functions) {
super(varTypes, functions);
}
public void addValue(String id, Sexp sexp) {
values.put(id, sexp);
}
@Override
public Value getValue(String name) {
Type type = varTypes.get(name);
if (type == null) {
throw new IllegalArgumentException("Model queried unknown variable: " + name);
}
Sexp sexp = values.get(name);
if (sexp == null) {
return Util.getDefaultValue(type);
}
Value value = new SexpEvaluator(this).eval(sexp);
return Util.promoteIfNeeded(value, type);
}
@Override
public Set<String> getVariableNames() {
return values.keySet();
}
@Override
public Value evaluateFunction(String name, List<Value> inputs) {
// Function value may be stored in the tables
Value parentResult = super.evaluateFunction(name, inputs);
if (parentResult != null) {
return parentResult;
}
// Function value will otherwise be computed from lambda s-expression
Sexp lambda = values.get(name);
if (lambda == null) {
return null;
}
Value value;
if (inputs.isEmpty()) {
value = new SexpEvaluator(this).eval(lambda);
} else {
Cons cons = (Cons) lambda;
Map<String, Value> env = zipMap(getArgNames(cons.args.get(0)), inputs);
Sexp body = cons.args.get(1);
value = new SexpEvaluator(env::get).eval(body);
}
Type type = getFunctionTable(name).getOutput().type;
return Util.promoteIfNeeded(value, type);
}
private List<String> getArgNames(Sexp sexp) {
if (sexp instanceof Symbol) {
return Collections.emptyList();
}
List<String> args = new ArrayList<>();
Cons cons = (Cons) sexp;
args.add(car(cons.head).toString());
for (Sexp next : cons.args) {
args.add(car(next).toString());
}
return args;
}
private Sexp car(Sexp sexp) {
return ((Cons) sexp).head;
}
private <K, V> Map<K, V> zipMap(List<K> keys, List<V> values) {
Map<K, V> result = new HashMap<>();
for (int i = 0; i < keys.size(); i++) {
result.put(keys.get(i), values.get(i));
}
return result;
}
}
| 2,545
| 23.718447
| 81
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/yices/YicesLexer.java
|
// Generated from Yices.g4 by ANTLR 4.4
package jkind.solvers.yices;
import org.antlr.v4.runtime.Lexer;
import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.Token;
import org.antlr.v4.runtime.TokenStream;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.misc.*;
@SuppressWarnings({ "all", "warnings", "unchecked", "unused", "cast" })
public class YicesLexer extends Lexer {
static {
RuntimeMetaData.checkVersion("4.4", RuntimeMetaData.VERSION);
}
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache();
public static final int T__12 = 1, T__11 = 2, T__10 = 3, T__9 = 4, T__8 = 5, T__7 = 6, T__6 = 7, T__5 = 8, T__4 = 9,
T__3 = 10, T__2 = 11, T__1 = 12, T__0 = 13, PREDEFINED_OP = 14, BOOL = 15, INT = 16, ID = 17, WS = 18,
ERROR = 19;
public static String[] modeNames = { "DEFAULT_MODE" };
public static final String[] tokenNames = { "'\\u0000'", "'\\u0001'", "'\\u0002'", "'\\u0003'", "'\\u0004'",
"'\\u0005'", "'\\u0006'", "'\\u0007'", "'\b'", "'\t'", "'\n'", "'\\u000B'", "'\f'", "'\r'", "'\\u000E'",
"'\\u000F'", "'\\u0010'", "'\\u0011'", "'\\u0012'", "'\\u0013'" };
public static final String[] ruleNames = { "T__12", "T__11", "T__10", "T__9", "T__8", "T__7", "T__6", "T__5",
"T__4", "T__3", "T__2", "T__1", "T__0", "PREDEFINED_OP", "BOOL", "DIGIT", "SYMBOL", "INT", "ID", "WS",
"ERROR" };
public YicesLexer(CharStream input) {
super(input);
_interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
}
@Override
public String getGrammarFileName() {
return "Yices.g4";
}
@Override
public String[] getTokenNames() {
return tokenNames;
}
@Override
public String[] getRuleNames() {
return ruleNames;
}
@Override
public String getSerializedATN() {
return _serializedATN;
}
@Override
public String[] getModeNames() {
return modeNames;
}
@Override
public ATN getATN() {
return _ATN;
}
public static final String _serializedATN = "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\2\25\u00a9\b\1\4\2"
+ "\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4"
+ "\13\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22"
+ "\t\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\3\2\3\2\3\3\3\3\3\3\3\3"
+ "\3\3\3\4\3\4\3\4\3\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\6\3\6\3"
+ "\6\3\6\3\6\3\7\3\7\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b\3\t\3\t\3\n\3\n\3\n"
+ "\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3"
+ "\13\3\13\3\13\3\13\3\f\3\f\3\r\3\r\3\16\3\16\3\17\3\17\3\17\3\17\3\17"
+ "\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17"
+ "\5\17\u0083\n\17\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\5\20\u008e"
+ "\n\20\3\21\3\21\3\22\3\22\3\23\6\23\u0095\n\23\r\23\16\23\u0096\3\24\3"
+ "\24\3\24\7\24\u009c\n\24\f\24\16\24\u009f\13\24\3\25\6\25\u00a2\n\25\r"
+ "\25\16\25\u00a3\3\25\3\25\3\26\3\26\2\2\27\3\3\5\4\7\5\t\6\13\7\r\b\17"
+ "\t\21\n\23\13\25\f\27\r\31\16\33\17\35\20\37\21!\2#\2%\22\'\23)\24+\25"
+ "\3\2\5\3\2\62;\t\2##%\'\60\60<<Bac|\u0080\u0080\5\2\13\f\16\17\"\"\u00ae"
+ "\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2"
+ "\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2"
+ "\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2\2%\3\2\2\2\2\'\3"
+ "\2\2\2\2)\3\2\2\2\2+\3\2\2\2\3-\3\2\2\2\5/\3\2\2\2\7\64\3\2\2\2\t:\3\2"
+ "\2\2\13B\3\2\2\2\rG\3\2\2\2\17M\3\2\2\2\21Q\3\2\2\2\23S\3\2\2\2\25]\3"
+ "\2\2\2\27i\3\2\2\2\31k\3\2\2\2\33m\3\2\2\2\35\u0082\3\2\2\2\37\u008d\3"
+ "\2\2\2!\u008f\3\2\2\2#\u0091\3\2\2\2%\u0094\3\2\2\2\'\u0098\3\2\2\2)\u00a1"
+ "\3\2\2\2+\u00a7\3\2\2\2-.\7\61\2\2.\4\3\2\2\2/\60\7k\2\2\60\61\7f\2\2"
+ "\61\62\7u\2\2\62\63\7<\2\2\63\6\3\2\2\2\64\65\7w\2\2\65\66\7p\2\2\66\67"
+ "\7u\2\2\678\7c\2\289\7v\2\29\b\3\2\2\2:;\7w\2\2;<\7p\2\2<=\7m\2\2=>\7"
+ "p\2\2>?\7q\2\2?@\7y\2\2@A\7p\2\2A\n\3\2\2\2BC\7e\2\2CD\7q\2\2DE\7t\2\2"
+ "EF\7g\2\2F\f\3\2\2\2GH\7e\2\2HI\7q\2\2IJ\7u\2\2JK\7v\2\2KL\7<\2\2L\16"
+ "\3\2\2\2MN\7u\2\2NO\7c\2\2OP\7v\2\2P\20\3\2\2\2QR\7?\2\2R\22\3\2\2\2S"
+ "T\7c\2\2TU\7u\2\2UV\7u\2\2VW\7g\2\2WX\7t\2\2XY\7v\2\2YZ\7k\2\2Z[\7q\2"
+ "\2[\\\7p\2\2\\\24\3\2\2\2]^\7w\2\2^_\7p\2\2_`\7u\2\2`a\7c\2\2ab\7v\2\2"
+ "bc\7k\2\2cd\7u\2\2de\7h\2\2ef\7k\2\2fg\7g\2\2gh\7f\2\2h\26\3\2\2\2ij\7"
+ "*\2\2j\30\3\2\2\2kl\7+\2\2l\32\3\2\2\2mn\7/\2\2n\34\3\2\2\2op\7o\2\2p"
+ "q\7q\2\2q\u0083\7f\2\2rs\7f\2\2st\7k\2\2t\u0083\7x\2\2uv\7v\2\2vw\7q\2"
+ "\2wx\7a\2\2xy\7k\2\2yz\7p\2\2z\u0083\7v\2\2{|\7v\2\2|}\7q\2\2}~\7a\2\2"
+ "~\177\7t\2\2\177\u0080\7g\2\2\u0080\u0081\7c\2\2\u0081\u0083\7n\2\2\u0082"
+ "o\3\2\2\2\u0082r\3\2\2\2\u0082u\3\2\2\2\u0082{\3\2\2\2\u0083\36\3\2\2"
+ "\2\u0084\u0085\7v\2\2\u0085\u0086\7t\2\2\u0086\u0087\7w\2\2\u0087\u008e"
+ "\7g\2\2\u0088\u0089\7h\2\2\u0089\u008a\7c\2\2\u008a\u008b\7n\2\2\u008b"
+ "\u008c\7u\2\2\u008c\u008e\7g\2\2\u008d\u0084\3\2\2\2\u008d\u0088\3\2\2"
+ "\2\u008e \3\2\2\2\u008f\u0090\t\2\2\2\u0090\"\3\2\2\2\u0091\u0092\t\3"
+ "\2\2\u0092$\3\2\2\2\u0093\u0095\5!\21\2\u0094\u0093\3\2\2\2\u0095\u0096"
+ "\3\2\2\2\u0096\u0094\3\2\2\2\u0096\u0097\3\2\2\2\u0097&\3\2\2\2\u0098"
+ "\u009d\5#\22\2\u0099\u009c\5#\22\2\u009a\u009c\5!\21\2\u009b\u0099\3\2"
+ "\2\2\u009b\u009a\3\2\2\2\u009c\u009f\3\2\2\2\u009d\u009b\3\2\2\2\u009d"
+ "\u009e\3\2\2\2\u009e(\3\2\2\2\u009f\u009d\3\2\2\2\u00a0\u00a2\t\4\2\2"
+ "\u00a1\u00a0\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3\u00a1\3\2\2\2\u00a3\u00a4"
+ "\3\2\2\2\u00a4\u00a5\3\2\2\2\u00a5\u00a6\b\25\2\2\u00a6*\3\2\2\2\u00a7"
+ "\u00a8\13\2\2\2\u00a8,\3\2\2\2\t\2\u0082\u008d\u0096\u009b\u009d\u00a3" + "\3\b\2\2";
public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray());
static {
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
}
}
}
| 6,154
| 49.04065
| 117
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/yices/YicesListener.java
|
// Generated from Yices.g4 by ANTLR 4.4
package jkind.solvers.yices;
import org.antlr.v4.runtime.misc.NotNull;
import org.antlr.v4.runtime.tree.ParseTreeListener;
/**
* This interface defines a complete listener for a parse tree produced by
* {@link YicesParser}.
*/
public interface YicesListener extends ParseTreeListener {
/**
* Enter a parse tree produced by {@link YicesParser#unsatResult}.
* @param ctx the parse tree
*/
void enterUnsatResult(@NotNull YicesParser.UnsatResultContext ctx);
/**
* Exit a parse tree produced by {@link YicesParser#unsatResult}.
* @param ctx the parse tree
*/
void exitUnsatResult(@NotNull YicesParser.UnsatResultContext ctx);
/**
* Enter a parse tree produced by {@link YicesParser#unsatAssertions}.
* @param ctx the parse tree
*/
void enterUnsatAssertions(@NotNull YicesParser.UnsatAssertionsContext ctx);
/**
* Exit a parse tree produced by {@link YicesParser#unsatAssertions}.
* @param ctx the parse tree
*/
void exitUnsatAssertions(@NotNull YicesParser.UnsatAssertionsContext ctx);
/**
* Enter a parse tree produced by {@link YicesParser#cost}.
* @param ctx the parse tree
*/
void enterCost(@NotNull YicesParser.CostContext ctx);
/**
* Exit a parse tree produced by {@link YicesParser#cost}.
* @param ctx the parse tree
*/
void exitCost(@NotNull YicesParser.CostContext ctx);
/**
* Enter a parse tree produced by {@link YicesParser#numeric}.
* @param ctx the parse tree
*/
void enterNumeric(@NotNull YicesParser.NumericContext ctx);
/**
* Exit a parse tree produced by {@link YicesParser#numeric}.
* @param ctx the parse tree
*/
void exitNumeric(@NotNull YicesParser.NumericContext ctx);
/**
* Enter a parse tree produced by {@link YicesParser#integer}.
* @param ctx the parse tree
*/
void enterInteger(@NotNull YicesParser.IntegerContext ctx);
/**
* Exit a parse tree produced by {@link YicesParser#integer}.
* @param ctx the parse tree
*/
void exitInteger(@NotNull YicesParser.IntegerContext ctx);
/**
* Enter a parse tree produced by {@link YicesParser#predefined}.
* @param ctx the parse tree
*/
void enterPredefined(@NotNull YicesParser.PredefinedContext ctx);
/**
* Exit a parse tree produced by {@link YicesParser#predefined}.
* @param ctx the parse tree
*/
void exitPredefined(@NotNull YicesParser.PredefinedContext ctx);
/**
* Enter a parse tree produced by {@link YicesParser#result}.
* @param ctx the parse tree
*/
void enterResult(@NotNull YicesParser.ResultContext ctx);
/**
* Exit a parse tree produced by {@link YicesParser#result}.
* @param ctx the parse tree
*/
void exitResult(@NotNull YicesParser.ResultContext ctx);
/**
* Enter a parse tree produced by {@link YicesParser#unsatCore}.
* @param ctx the parse tree
*/
void enterUnsatCore(@NotNull YicesParser.UnsatCoreContext ctx);
/**
* Exit a parse tree produced by {@link YicesParser#unsatCore}.
* @param ctx the parse tree
*/
void exitUnsatCore(@NotNull YicesParser.UnsatCoreContext ctx);
/**
* Enter a parse tree produced by {@link YicesParser#satResult}.
* @param ctx the parse tree
*/
void enterSatResult(@NotNull YicesParser.SatResultContext ctx);
/**
* Exit a parse tree produced by {@link YicesParser#satResult}.
* @param ctx the parse tree
*/
void exitSatResult(@NotNull YicesParser.SatResultContext ctx);
/**
* Enter a parse tree produced by {@link YicesParser#function}.
* @param ctx the parse tree
*/
void enterFunction(@NotNull YicesParser.FunctionContext ctx);
/**
* Exit a parse tree produced by {@link YicesParser#function}.
* @param ctx the parse tree
*/
void exitFunction(@NotNull YicesParser.FunctionContext ctx);
/**
* Enter a parse tree produced by {@link YicesParser#variable}.
* @param ctx the parse tree
*/
void enterVariable(@NotNull YicesParser.VariableContext ctx);
/**
* Exit a parse tree produced by {@link YicesParser#variable}.
* @param ctx the parse tree
*/
void exitVariable(@NotNull YicesParser.VariableContext ctx);
/**
* Enter a parse tree produced by {@link YicesParser#alias}.
* @param ctx the parse tree
*/
void enterAlias(@NotNull YicesParser.AliasContext ctx);
/**
* Exit a parse tree produced by {@link YicesParser#alias}.
* @param ctx the parse tree
*/
void exitAlias(@NotNull YicesParser.AliasContext ctx);
/**
* Enter a parse tree produced by {@link YicesParser#model}.
* @param ctx the parse tree
*/
void enterModel(@NotNull YicesParser.ModelContext ctx);
/**
* Exit a parse tree produced by {@link YicesParser#model}.
* @param ctx the parse tree
*/
void exitModel(@NotNull YicesParser.ModelContext ctx);
/**
* Enter a parse tree produced by {@link YicesParser#value}.
* @param ctx the parse tree
*/
void enterValue(@NotNull YicesParser.ValueContext ctx);
/**
* Exit a parse tree produced by {@link YicesParser#value}.
* @param ctx the parse tree
*/
void exitValue(@NotNull YicesParser.ValueContext ctx);
}
| 5,017
| 27.03352
| 76
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/yices/Label.java
|
package jkind.solvers.yices;
public class Label {
final private String name;
public Label(String name) {
this.name = name;
}
public Label(int i) {
this.name = Integer.toString(i);
}
@Override
public String toString() {
return name;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (!(obj instanceof Label)) {
return false;
}
Label other = (Label) obj;
if (name == null) {
if (other.name != null) {
return false;
}
} else if (!name.equals(other.name)) {
return false;
}
return true;
}
}
| 790
| 15.142857
| 67
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/yices/YicesBaseListener.java
|
// Generated from Yices.g4 by ANTLR 4.4
package jkind.solvers.yices;
import org.antlr.v4.runtime.ParserRuleContext;
import org.antlr.v4.runtime.misc.NotNull;
import org.antlr.v4.runtime.tree.ErrorNode;
import org.antlr.v4.runtime.tree.TerminalNode;
/**
* This class provides an empty implementation of {@link YicesListener},
* which can be extended to create a listener which only needs to handle a subset
* of the available methods.
*/
public class YicesBaseListener implements YicesListener {
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterUnsatResult(@NotNull YicesParser.UnsatResultContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitUnsatResult(@NotNull YicesParser.UnsatResultContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterUnsatAssertions(@NotNull YicesParser.UnsatAssertionsContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitUnsatAssertions(@NotNull YicesParser.UnsatAssertionsContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterCost(@NotNull YicesParser.CostContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitCost(@NotNull YicesParser.CostContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterNumeric(@NotNull YicesParser.NumericContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitNumeric(@NotNull YicesParser.NumericContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterInteger(@NotNull YicesParser.IntegerContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitInteger(@NotNull YicesParser.IntegerContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterPredefined(@NotNull YicesParser.PredefinedContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitPredefined(@NotNull YicesParser.PredefinedContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterResult(@NotNull YicesParser.ResultContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitResult(@NotNull YicesParser.ResultContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterUnsatCore(@NotNull YicesParser.UnsatCoreContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitUnsatCore(@NotNull YicesParser.UnsatCoreContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterSatResult(@NotNull YicesParser.SatResultContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitSatResult(@NotNull YicesParser.SatResultContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterFunction(@NotNull YicesParser.FunctionContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitFunction(@NotNull YicesParser.FunctionContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterVariable(@NotNull YicesParser.VariableContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitVariable(@NotNull YicesParser.VariableContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterAlias(@NotNull YicesParser.AliasContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitAlias(@NotNull YicesParser.AliasContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterModel(@NotNull YicesParser.ModelContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitModel(@NotNull YicesParser.ModelContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterValue(@NotNull YicesParser.ValueContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitValue(@NotNull YicesParser.ValueContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterEveryRule(@NotNull ParserRuleContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitEveryRule(@NotNull ParserRuleContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void visitTerminal(@NotNull TerminalNode node) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void visitErrorNode(@NotNull ErrorNode node) {
}
}
| 5,866
| 18.427152
| 84
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/yices/YicesParser.java
|
// Generated from Yices.g4 by ANTLR 4.4
package jkind.solvers.yices;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({ "all", "warnings", "unchecked", "unused", "cast" })
public class YicesParser extends Parser {
static {
RuntimeMetaData.checkVersion("4.4", RuntimeMetaData.VERSION);
}
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache();
public static final int T__12 = 1, T__11 = 2, T__10 = 3, T__9 = 4, T__8 = 5, T__7 = 6, T__6 = 7, T__5 = 8, T__4 = 9,
T__3 = 10, T__2 = 11, T__1 = 12, T__0 = 13, PREDEFINED_OP = 14, BOOL = 15, INT = 16, ID = 17, WS = 18,
ERROR = 19;
public static final String[] tokenNames = { "<INVALID>", "'/'", "'ids:'", "'unsat'", "'unknown'", "'core'",
"'cost:'", "'sat'", "'='", "'assertion'", "'unsatisfied'", "'('", "')'", "'-'", "PREDEFINED_OP", "BOOL",
"INT", "ID", "WS", "ERROR" };
public static final int RULE_result = 0, RULE_satResult = 1, RULE_unsatResult = 2, RULE_model = 3,
RULE_unsatAssertions = 4, RULE_cost = 5, RULE_unsatCore = 6, RULE_alias = 7, RULE_variable = 8,
RULE_function = 9, RULE_predefined = 10, RULE_value = 11, RULE_integer = 12, RULE_numeric = 13;
public static final String[] ruleNames = { "result", "satResult", "unsatResult", "model", "unsatAssertions", "cost",
"unsatCore", "alias", "variable", "function", "predefined", "value", "integer", "numeric" };
@Override
public String getGrammarFileName() {
return "Yices.g4";
}
@Override
public String[] getTokenNames() {
return tokenNames;
}
@Override
public String[] getRuleNames() {
return ruleNames;
}
@Override
public String getSerializedATN() {
return _serializedATN;
}
@Override
public ATN getATN() {
return _ATN;
}
public YicesParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
}
public static class ResultContext extends ParserRuleContext {
public TerminalNode EOF() {
return getToken(YicesParser.EOF, 0);
}
public SatResultContext satResult() {
return getRuleContext(SatResultContext.class, 0);
}
public UnsatResultContext unsatResult() {
return getRuleContext(UnsatResultContext.class, 0);
}
public ResultContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_result;
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).enterResult(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).exitResult(this);
}
}
public final ResultContext result() throws RecognitionException {
ResultContext _localctx = new ResultContext(_ctx, getState());
enterRule(_localctx, 0, RULE_result);
try {
enterOuterAlt(_localctx, 1);
{
setState(30);
switch (_input.LA(1)) {
case T__9:
case T__6: {
setState(28);
satResult();
}
break;
case T__10: {
setState(29);
unsatResult();
}
break;
default:
throw new NoViableAltException(this);
}
setState(32);
match(EOF);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class SatResultContext extends ParserRuleContext {
public UnsatAssertionsContext unsatAssertions() {
return getRuleContext(UnsatAssertionsContext.class, 0);
}
public CostContext cost() {
return getRuleContext(CostContext.class, 0);
}
public ModelContext model() {
return getRuleContext(ModelContext.class, 0);
}
public SatResultContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_satResult;
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).enterSatResult(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).exitSatResult(this);
}
}
public final SatResultContext satResult() throws RecognitionException {
SatResultContext _localctx = new SatResultContext(_ctx, getState());
enterRule(_localctx, 2, RULE_satResult);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(34);
_la = _input.LA(1);
if (!(_la == T__9 || _la == T__6)) {
_errHandler.recoverInline(this);
}
consume();
setState(36);
_la = _input.LA(1);
if (_la == T__3) {
{
setState(35);
unsatAssertions();
}
}
setState(39);
_la = _input.LA(1);
if (_la == T__2) {
{
setState(38);
model();
}
}
setState(42);
_la = _input.LA(1);
if (_la == T__7) {
{
setState(41);
cost();
}
}
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class UnsatResultContext extends ParserRuleContext {
public UnsatCoreContext unsatCore() {
return getRuleContext(UnsatCoreContext.class, 0);
}
public UnsatResultContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_unsatResult;
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).enterUnsatResult(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).exitUnsatResult(this);
}
}
public final UnsatResultContext unsatResult() throws RecognitionException {
UnsatResultContext _localctx = new UnsatResultContext(_ctx, getState());
enterRule(_localctx, 4, RULE_unsatResult);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(44);
match(T__10);
setState(46);
_la = _input.LA(1);
if (_la == T__10) {
{
setState(45);
unsatCore();
}
}
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class ModelContext extends ParserRuleContext {
public List<AliasContext> alias() {
return getRuleContexts(AliasContext.class);
}
public PredefinedContext predefined(int i) {
return getRuleContext(PredefinedContext.class, i);
}
public AliasContext alias(int i) {
return getRuleContext(AliasContext.class, i);
}
public FunctionContext function(int i) {
return getRuleContext(FunctionContext.class, i);
}
public VariableContext variable(int i) {
return getRuleContext(VariableContext.class, i);
}
public List<PredefinedContext> predefined() {
return getRuleContexts(PredefinedContext.class);
}
public List<VariableContext> variable() {
return getRuleContexts(VariableContext.class);
}
public List<FunctionContext> function() {
return getRuleContexts(FunctionContext.class);
}
public ModelContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_model;
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).enterModel(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).exitModel(this);
}
}
public final ModelContext model() throws RecognitionException {
ModelContext _localctx = new ModelContext(_ctx, getState());
enterRule(_localctx, 6, RULE_model);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(52);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
setState(52);
switch (getInterpreter().adaptivePredict(_input, 5, _ctx)) {
case 1: {
setState(48);
alias();
}
break;
case 2: {
setState(49);
variable();
}
break;
case 3: {
setState(50);
function();
}
break;
case 4: {
setState(51);
predefined();
}
break;
}
}
setState(54);
_errHandler.sync(this);
_la = _input.LA(1);
} while (_la == T__2);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class UnsatAssertionsContext extends ParserRuleContext {
public TerminalNode INT(int i) {
return getToken(YicesParser.INT, i);
}
public List<TerminalNode> INT() {
return getTokens(YicesParser.INT);
}
public UnsatAssertionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_unsatAssertions;
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).enterUnsatAssertions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).exitUnsatAssertions(this);
}
}
public final UnsatAssertionsContext unsatAssertions() throws RecognitionException {
UnsatAssertionsContext _localctx = new UnsatAssertionsContext(_ctx, getState());
enterRule(_localctx, 8, RULE_unsatAssertions);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(56);
match(T__3);
setState(57);
match(T__4);
setState(58);
match(T__11);
setState(60);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(59);
match(INT);
}
}
setState(62);
_errHandler.sync(this);
_la = _input.LA(1);
} while (_la == INT);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class CostContext extends ParserRuleContext {
public TerminalNode INT() {
return getToken(YicesParser.INT, 0);
}
public CostContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_cost;
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).enterCost(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).exitCost(this);
}
}
public final CostContext cost() throws RecognitionException {
CostContext _localctx = new CostContext(_ctx, getState());
enterRule(_localctx, 10, RULE_cost);
try {
enterOuterAlt(_localctx, 1);
{
setState(64);
match(T__7);
setState(65);
match(INT);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class UnsatCoreContext extends ParserRuleContext {
public TerminalNode INT(int i) {
return getToken(YicesParser.INT, i);
}
public List<TerminalNode> INT() {
return getTokens(YicesParser.INT);
}
public UnsatCoreContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_unsatCore;
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).enterUnsatCore(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).exitUnsatCore(this);
}
}
public final UnsatCoreContext unsatCore() throws RecognitionException {
UnsatCoreContext _localctx = new UnsatCoreContext(_ctx, getState());
enterRule(_localctx, 12, RULE_unsatCore);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(67);
match(T__10);
setState(68);
match(T__8);
setState(69);
match(T__11);
setState(71);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(70);
match(INT);
}
}
setState(73);
_errHandler.sync(this);
_la = _input.LA(1);
} while (_la == INT);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class AliasContext extends ParserRuleContext {
public List<TerminalNode> ID() {
return getTokens(YicesParser.ID);
}
public TerminalNode ID(int i) {
return getToken(YicesParser.ID, i);
}
public AliasContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_alias;
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).enterAlias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).exitAlias(this);
}
}
public final AliasContext alias() throws RecognitionException {
AliasContext _localctx = new AliasContext(_ctx, getState());
enterRule(_localctx, 14, RULE_alias);
try {
enterOuterAlt(_localctx, 1);
{
setState(75);
match(T__2);
setState(76);
match(T__5);
setState(77);
match(ID);
setState(78);
match(ID);
setState(79);
match(T__1);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class VariableContext extends ParserRuleContext {
public TerminalNode ID() {
return getToken(YicesParser.ID, 0);
}
public ValueContext value() {
return getRuleContext(ValueContext.class, 0);
}
public VariableContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_variable;
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).enterVariable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).exitVariable(this);
}
}
public final VariableContext variable() throws RecognitionException {
VariableContext _localctx = new VariableContext(_ctx, getState());
enterRule(_localctx, 16, RULE_variable);
try {
enterOuterAlt(_localctx, 1);
{
setState(81);
match(T__2);
setState(82);
match(T__5);
setState(83);
match(ID);
setState(84);
value();
setState(85);
match(T__1);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class FunctionContext extends ParserRuleContext {
public TerminalNode ID() {
return getToken(YicesParser.ID, 0);
}
public List<ValueContext> value() {
return getRuleContexts(ValueContext.class);
}
public ValueContext value(int i) {
return getRuleContext(ValueContext.class, i);
}
public FunctionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_function;
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).enterFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).exitFunction(this);
}
}
public final FunctionContext function() throws RecognitionException {
FunctionContext _localctx = new FunctionContext(_ctx, getState());
enterRule(_localctx, 18, RULE_function);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(87);
match(T__2);
setState(88);
match(T__5);
setState(89);
match(T__2);
setState(90);
match(ID);
setState(92);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(91);
value();
}
}
setState(94);
_errHandler.sync(this);
_la = _input.LA(1);
} while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << BOOL) | (1L << INT))) != 0));
setState(96);
match(T__1);
setState(97);
value();
setState(98);
match(T__1);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class PredefinedContext extends ParserRuleContext {
public List<ValueContext> value() {
return getRuleContexts(ValueContext.class);
}
public ValueContext value(int i) {
return getRuleContext(ValueContext.class, i);
}
public TerminalNode PREDEFINED_OP() {
return getToken(YicesParser.PREDEFINED_OP, 0);
}
public PredefinedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_predefined;
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).enterPredefined(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).exitPredefined(this);
}
}
public final PredefinedContext predefined() throws RecognitionException {
PredefinedContext _localctx = new PredefinedContext(_ctx, getState());
enterRule(_localctx, 20, RULE_predefined);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(100);
match(T__2);
setState(101);
match(T__5);
setState(102);
match(T__2);
setState(103);
match(PREDEFINED_OP);
setState(107);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << BOOL) | (1L << INT))) != 0)) {
{
{
setState(104);
value();
}
}
setState(109);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(110);
match(T__1);
setState(111);
value();
setState(112);
match(T__1);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class ValueContext extends ParserRuleContext {
public NumericContext numeric() {
return getRuleContext(NumericContext.class, 0);
}
public TerminalNode BOOL() {
return getToken(YicesParser.BOOL, 0);
}
public ValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_value;
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).enterValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).exitValue(this);
}
}
public final ValueContext value() throws RecognitionException {
ValueContext _localctx = new ValueContext(_ctx, getState());
enterRule(_localctx, 22, RULE_value);
try {
setState(116);
switch (_input.LA(1)) {
case BOOL:
enterOuterAlt(_localctx, 1); {
setState(114);
match(BOOL);
}
break;
case T__0:
case INT:
enterOuterAlt(_localctx, 2); {
setState(115);
numeric();
}
break;
default:
throw new NoViableAltException(this);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class IntegerContext extends ParserRuleContext {
public TerminalNode INT() {
return getToken(YicesParser.INT, 0);
}
public IntegerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_integer;
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).enterInteger(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).exitInteger(this);
}
}
public final IntegerContext integer() throws RecognitionException {
IntegerContext _localctx = new IntegerContext(_ctx, getState());
enterRule(_localctx, 24, RULE_integer);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(119);
_la = _input.LA(1);
if (_la == T__0) {
{
setState(118);
match(T__0);
}
}
setState(121);
match(INT);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class NumericContext extends ParserRuleContext {
public TerminalNode INT(int i) {
return getToken(YicesParser.INT, i);
}
public List<TerminalNode> INT() {
return getTokens(YicesParser.INT);
}
public NumericContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_numeric;
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).enterNumeric(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof YicesListener)
((YicesListener) listener).exitNumeric(this);
}
}
public final NumericContext numeric() throws RecognitionException {
NumericContext _localctx = new NumericContext(_ctx, getState());
enterRule(_localctx, 26, RULE_numeric);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(124);
_la = _input.LA(1);
if (_la == T__0) {
{
setState(123);
match(T__0);
}
}
setState(126);
match(INT);
setState(129);
_la = _input.LA(1);
if (_la == T__12) {
{
setState(127);
match(T__12);
setState(128);
match(INT);
}
}
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static final String _serializedATN = "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\25\u0086\4\2\t\2"
+ "\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"
+ "\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\3\2\3\2\5\2!\n\2\3\2\3\2\3\3"
+ "\3\3\5\3\'\n\3\3\3\5\3*\n\3\3\3\5\3-\n\3\3\4\3\4\5\4\61\n\4\3\5\3\5\3"
+ "\5\3\5\6\5\67\n\5\r\5\16\58\3\6\3\6\3\6\3\6\6\6?\n\6\r\6\16\6@\3\7\3\7"
+ "\3\7\3\b\3\b\3\b\3\b\6\bJ\n\b\r\b\16\bK\3\t\3\t\3\t\3\t\3\t\3\t\3\n\3"
+ "\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\6\13_\n\13\r\13\16\13`\3\13"
+ "\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\7\fl\n\f\f\f\16\fo\13\f\3\f\3\f\3"
+ "\f\3\f\3\r\3\r\5\rw\n\r\3\16\5\16z\n\16\3\16\3\16\3\17\5\17\177\n\17\3"
+ "\17\3\17\3\17\5\17\u0084\n\17\3\17\2\2\20\2\4\6\b\n\f\16\20\22\24\26\30"
+ "\32\34\2\3\4\2\6\6\t\t\u0088\2 \3\2\2\2\4$\3\2\2\2\6.\3\2\2\2\b\66\3\2"
+ "\2\2\n:\3\2\2\2\fB\3\2\2\2\16E\3\2\2\2\20M\3\2\2\2\22S\3\2\2\2\24Y\3\2"
+ "\2\2\26f\3\2\2\2\30v\3\2\2\2\32y\3\2\2\2\34~\3\2\2\2\36!\5\4\3\2\37!\5"
+ "\6\4\2 \36\3\2\2\2 \37\3\2\2\2!\"\3\2\2\2\"#\7\2\2\3#\3\3\2\2\2$&\t\2"
+ "\2\2%\'\5\n\6\2&%\3\2\2\2&\'\3\2\2\2\')\3\2\2\2(*\5\b\5\2)(\3\2\2\2)*"
+ "\3\2\2\2*,\3\2\2\2+-\5\f\7\2,+\3\2\2\2,-\3\2\2\2-\5\3\2\2\2.\60\7\5\2"
+ "\2/\61\5\16\b\2\60/\3\2\2\2\60\61\3\2\2\2\61\7\3\2\2\2\62\67\5\20\t\2"
+ "\63\67\5\22\n\2\64\67\5\24\13\2\65\67\5\26\f\2\66\62\3\2\2\2\66\63\3\2"
+ "\2\2\66\64\3\2\2\2\66\65\3\2\2\2\678\3\2\2\28\66\3\2\2\289\3\2\2\29\t"
+ "\3\2\2\2:;\7\f\2\2;<\7\13\2\2<>\7\4\2\2=?\7\22\2\2>=\3\2\2\2?@\3\2\2\2"
+ "@>\3\2\2\2@A\3\2\2\2A\13\3\2\2\2BC\7\b\2\2CD\7\22\2\2D\r\3\2\2\2EF\7\5"
+ "\2\2FG\7\7\2\2GI\7\4\2\2HJ\7\22\2\2IH\3\2\2\2JK\3\2\2\2KI\3\2\2\2KL\3"
+ "\2\2\2L\17\3\2\2\2MN\7\r\2\2NO\7\n\2\2OP\7\23\2\2PQ\7\23\2\2QR\7\16\2"
+ "\2R\21\3\2\2\2ST\7\r\2\2TU\7\n\2\2UV\7\23\2\2VW\5\30\r\2WX\7\16\2\2X\23"
+ "\3\2\2\2YZ\7\r\2\2Z[\7\n\2\2[\\\7\r\2\2\\^\7\23\2\2]_\5\30\r\2^]\3\2\2"
+ "\2_`\3\2\2\2`^\3\2\2\2`a\3\2\2\2ab\3\2\2\2bc\7\16\2\2cd\5\30\r\2de\7\16"
+ "\2\2e\25\3\2\2\2fg\7\r\2\2gh\7\n\2\2hi\7\r\2\2im\7\20\2\2jl\5\30\r\2k"
+ "j\3\2\2\2lo\3\2\2\2mk\3\2\2\2mn\3\2\2\2np\3\2\2\2om\3\2\2\2pq\7\16\2\2"
+ "qr\5\30\r\2rs\7\16\2\2s\27\3\2\2\2tw\7\21\2\2uw\5\34\17\2vt\3\2\2\2vu"
+ "\3\2\2\2w\31\3\2\2\2xz\7\17\2\2yx\3\2\2\2yz\3\2\2\2z{\3\2\2\2{|\7\22\2"
+ "\2|\33\3\2\2\2}\177\7\17\2\2~}\3\2\2\2~\177\3\2\2\2\177\u0080\3\2\2\2"
+ "\u0080\u0083\7\22\2\2\u0081\u0082\7\3\2\2\u0082\u0084\7\22\2\2\u0083\u0081"
+ "\3\2\2\2\u0083\u0084\3\2\2\2\u0084\35\3\2\2\2\21 &),\60\668@K`mvy~\u0083";
public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray());
static {
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
}
}
}
| 26,914
| 24.037209
| 117
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/yices/ResultExtractorListener.java
|
package jkind.solvers.yices;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import org.antlr.v4.runtime.tree.TerminalNode;
import jkind.lustre.Function;
import jkind.lustre.Type;
import jkind.lustre.values.Value;
import jkind.results.FunctionTable;
import jkind.sexp.Symbol;
import jkind.solvers.Result;
import jkind.solvers.SatResult;
import jkind.solvers.UnsatResult;
import jkind.solvers.yices.YicesParser.AliasContext;
import jkind.solvers.yices.YicesParser.FunctionContext;
import jkind.solvers.yices.YicesParser.SatResultContext;
import jkind.solvers.yices.YicesParser.UnsatCoreContext;
import jkind.solvers.yices.YicesParser.UnsatResultContext;
import jkind.solvers.yices.YicesParser.VariableContext;
import jkind.util.SexpUtil;
import jkind.util.Util;
public class ResultExtractorListener extends YicesBaseListener {
private Result result;
private YicesModel model;
private List<Symbol> unsatCore;
private final Map<String, Type> varTypes;
private final List<Function> functions;
public ResultExtractorListener(Map<String, Type> varTypes, List<Function> functions) {
this.varTypes = varTypes;
this.functions = functions;
}
public Result getResult() {
return result;
}
@Override
public void enterSatResult(SatResultContext ctx) {
model = new YicesModel(varTypes, functions);
result = new SatResult(model);
}
@Override
public void enterUnsatResult(UnsatResultContext ctx) {
unsatCore = new ArrayList<>();
}
@Override
public void enterUnsatCore(UnsatCoreContext ctx) {
for (TerminalNode node : ctx.INT()) {
unsatCore.add(new Symbol(node.getText()));
}
}
@Override
public void exitUnsatResult(UnsatResultContext ctx) {
result = new UnsatResult(unsatCore);
}
@Override
public void enterAlias(AliasContext ctx) {
model.addAlias(ctx.ID(0).getText(), ctx.ID(1).getText());
}
@Override
public void enterVariable(VariableContext ctx) {
String var = ctx.ID().getText();
if (SexpUtil.isEncodedFunction(var)) {
// Nullary function value
FunctionTable table = model.getFunctionTable(var);
Type type = table.getOutput().type;
Value value = Util.parseValue(type, ctx.value().getText());
table.addRow(Collections.emptyList(), value);
} else {
Type type = varTypes.get(var);
if (type != null) {
model.addValue(var, Util.parseValue(type, ctx.value().getText()));
}
}
}
@Override
public void enterFunction(FunctionContext ctx) {
String name = ctx.ID().getText();
FunctionTable table = model.getFunctionTable(name);
int n = ctx.value().size();
List<Value> inputs = new ArrayList<>();
for (int i = 0; i < n - 1; i++) {
String type = Util.getName(table.getInputs().get(i).type);
inputs.add(Util.parseValue(type, ctx.value(i).getText()));
}
String type = table.getOutput().type.toString();
Value output = Util.parseValue(type, ctx.value(n - 1).getText());
table.addRow(inputs, output);
}
}
| 2,959
| 26.924528
| 87
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/yices/YicesSolver.java
|
package jkind.solvers.yices;
import static java.util.stream.Collectors.toList;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import org.antlr.v4.runtime.ANTLRInputStream;
import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.RecognitionException;
import org.antlr.v4.runtime.tree.ParseTreeWalker;
import jkind.JKindException;
import jkind.lustre.BinaryExpr;
import jkind.lustre.BinaryOp;
import jkind.lustre.CastExpr;
import jkind.lustre.Expr;
import jkind.lustre.Function;
import jkind.lustre.NamedType;
import jkind.lustre.Type;
import jkind.lustre.VarDecl;
import jkind.lustre.visitors.ExprConjunctiveVisitor;
import jkind.sexp.Cons;
import jkind.sexp.Sexp;
import jkind.sexp.Symbol;
import jkind.solvers.MaxSatSolver;
import jkind.solvers.ProcessBasedSolver;
import jkind.solvers.Result;
import jkind.solvers.SolverParserErrorListener;
import jkind.solvers.UnsatResult;
import jkind.solvers.yices.YicesParser.ResultContext;
import jkind.translation.Relation;
import jkind.util.SexpUtil;
import jkind.util.Util;
public class YicesSolver extends ProcessBasedSolver implements MaxSatSolver {
private final boolean arithOnly;
public YicesSolver(String scratchBase, boolean arithOnly) {
super(scratchBase);
this.arithOnly = arithOnly;
}
@Override
protected String getSolverName() {
return "Yices";
}
@Override
public void initialize() {
send("(set-evidence! true)");
if (arithOnly) {
send("(set-arith-only! true)");
} else {
send("(define to_int::(-> x::real (subtype (y::int) (and (<= y x) (< x (+ y 1))))))");
send("(define to_real::(-> x::int (subtype (y::real) (= y x))))");
}
}
@Override
public void assertSexp(Sexp sexp) {
send("(assert " + sexp + ")");
}
private void send(String str) {
scratch(str);
try {
toSolver.append(str);
toSolver.newLine();
toSolver.flush();
} catch (IOException e) {
throw new JKindException("Unable to write to yices, " + "probably due to internal JKind error", e);
}
}
private Symbol type(Type type) {
return new Symbol(Util.getName(type));
}
@Override
public void define(VarDecl decl) {
varTypes.put(decl.id, decl.type);
send("(define " + decl.id + " :: " + type(decl.type) + ")");
}
@Override
public void declare(Function function) {
functions.add(function);
if (function.inputs.isEmpty()) {
declareNullaryFunction(function);
} else {
declareFunction(function);
}
}
private void declareNullaryFunction(Function function) {
String name = SexpUtil.encodeFunction(function.id);
Symbol type = type(function.outputs.get(0).type);
send("(define " + name + " :: " + type + ")");
}
private void declareFunction(Function function) {
String name = SexpUtil.encodeFunction(function.id);
List<Sexp> args = new ArrayList<>();
for (VarDecl input : function.inputs) {
args.add(type(input.type));
}
args.add(type(function.outputs.get(0).type));
send("(define " + name + " :: " + new Cons("->", args) + ")");
}
@Override
public void define(Relation relation) {
send("(define " + relation.getName() + " :: " + type(relation) + " " + lambda(relation) + ")");
}
private Sexp type(Relation relation) {
List<Sexp> args = new ArrayList<>();
for (VarDecl vd : relation.getInputs()) {
args.add(type(vd.type));
}
args.add(type(NamedType.BOOL));
return new Cons("->", args);
}
private Sexp lambda(Relation relation) {
List<Sexp> args = new ArrayList<>();
for (VarDecl vd : relation.getInputs()) {
args.add(new Symbol(vd.id));
args.add(new Symbol("::"));
args.add(type(vd.type));
}
return new Cons("lambda", new Cons(args), relation.getBody());
}
private int labelCount = 1;
public Symbol labelledAssert(Sexp sexp) {
comment("id = " + labelCount);
send("(assert+ " + sexp + ")");
return new Symbol(Integer.toString(labelCount++));
}
public void retract(Symbol label) {
send("(retract " + label + ")");
}
@Override
public Result query(Sexp sexp) {
/**
* Using assert+ and retract seems to be much more efficient than push
* and pop for some reason.
*/
Symbol label = labelledAssert(new Cons("not", sexp));
send("(check)");
retract(label);
Result result = readResult();
if (result instanceof UnsatResult) {
List<Symbol> core = ((UnsatResult) result).getUnsatCore();
if (core.contains(label)) {
core.remove(label);
} else {
throw new JKindException("Unsat result did not depend on query");
}
}
return result;
}
@Override
public Result unsatQuery(List<Symbol> activationLiterals, Sexp query) {
push();
HashMap<Symbol, Symbol> labelToActivationLiteral = new HashMap<>();
for (Symbol actLit : activationLiterals) {
Symbol label = labelledAssert(actLit);
labelToActivationLiteral.put(label, actLit);
}
/** First use unsat-core to quickly remove many activationLiterals */
Result result = query(query);
if (!(result instanceof UnsatResult)) {
pop();
return result;
}
List<Symbol> labelCore = ((UnsatResult) result).getUnsatCore();
for (Symbol label : labelToActivationLiteral.keySet()) {
if (!labelCore.contains(label)) {
retract(label);
}
}
/** Then try removing activation literals one-by-one */
Iterator<Symbol> iterator = labelCore.iterator();
while (iterator.hasNext()) {
Symbol curr = iterator.next();
push();
retract(curr);
boolean unsat = query(query) instanceof UnsatResult;
pop();
if (unsat) {
retract(curr);
iterator.remove();
}
}
pop();
List<Symbol> core = labelCore.stream().map(labelToActivationLiteral::get).collect(toList());
return new UnsatResult(core);
}
@Override
protected Result quickCheckSat(List<Symbol> activationLiterals) {
// We do not need this method since we are overriding unsatQuery
throw new UnsupportedOperationException();
}
@Override
public void assertSoft(Sexp sexp) {
comment("id = " + labelCount);
send("(assert+ " + sexp + " 1)");
labelCount++;
}
@Override
public Result maxsatQuery(Sexp sexp) {
Symbol label = labelledAssert(new Cons("not", sexp));
send("(max-sat)");
retract(label);
return readResult();
}
private Result readResult() {
send("(echo \"" + DONE + "\\n\")");
try {
String line;
StringBuilder content = new StringBuilder();
boolean seenContextError = false;
while (true) {
line = fromSolver.readLine();
comment("YICES: " + line);
if (line == null) {
throw new JKindException("Yices terminated unexpectedly");
} else if (line.contains("Error:")) {
throw new JKindException("Yices error: " + line);
} else if (line.startsWith("Logical context")) {
/*
* One instance of a 'Logical context' message may come from
* the query we are asserting, but two instances indicates
* that some assumption about the system is false
*/
if (seenContextError) {
throw new JKindException("Lustre program is inconsistent");
}
seenContextError = true;
continue;
} else if (line.equals(DONE)) {
break;
} else {
content.append(line);
content.append("\n");
}
}
return parseYices(content.toString());
} catch (RecognitionException e) {
throw new JKindException("Error parsing Yices output", e);
} catch (IOException e) {
throw new JKindException("Unable to read from yices", e);
}
}
private Result parseYices(String string) throws RecognitionException {
CharStream stream = new ANTLRInputStream(string);
YicesLexer lexer = new YicesLexer(stream);
CommonTokenStream tokens = new CommonTokenStream(lexer);
YicesParser parser = new YicesParser(tokens);
parser.removeErrorListeners();
parser.addErrorListener(new SolverParserErrorListener());
ResultContext ctx = parser.result();
if (parser.getNumberOfSyntaxErrors() > 0) {
throw new JKindException("Error parsing Yices output: " + string);
}
ParseTreeWalker walker = new ParseTreeWalker();
ResultExtractorListener extractor = new ResultExtractorListener(varTypes, functions);
walker.walk(extractor, ctx);
Result result = extractor.getResult();
if (result == null) {
throw new JKindException("Unknown result from yices");
}
return result;
}
@Override
public void push() {
send("(push)");
}
@Override
public void pop() {
send("(pop)");
}
@Override
protected String getSolverExtension() {
return "yc";
}
@Override
public boolean supports(Expr expr) {
if (!arithOnly) {
return true;
}
return expr.accept(new ExprConjunctiveVisitor() {
@Override
public Boolean visit(BinaryExpr e) {
return e.op != BinaryOp.INT_DIVIDE && e.op != BinaryOp.MODULUS && super.visit(e);
}
@Override
public Boolean visit(CastExpr e) {
return false;
}
});
}
}
| 8,875
| 24.953216
| 102
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/yices/YicesModel.java
|
package jkind.solvers.yices;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import jkind.lustre.Function;
import jkind.lustre.Type;
import jkind.lustre.values.Value;
import jkind.solvers.Model;
import jkind.util.Util;
public class YicesModel extends Model {
protected final Map<String, String> aliases = new HashMap<>();
protected final Map<String, Value> values = new HashMap<>();
public YicesModel(Map<String, Type> varTypes, List<Function> functions) {
super(varTypes, functions);
}
public void addAlias(String from, String to) {
aliases.put(from, to);
}
public void addValue(String name, Value value) {
values.put(name, value);
}
protected String getAlias(String name) {
String result = name;
while (aliases.containsKey(result)) {
result = aliases.get(result);
}
return result;
}
@Override
public Value getValue(String name) {
Type type = varTypes.get(name);
if (type == null) {
throw new IllegalArgumentException("Model queried unknown variable: " + name);
}
Value value = values.get(getAlias(name));
if (value == null) {
return Util.getDefaultValue(type);
} else {
return Util.promoteIfNeeded(value, type);
}
}
@Override
public Set<String> getVariableNames() {
Set<String> result = new HashSet<>();
result.addAll(aliases.keySet());
result.addAll(values.keySet());
return result;
}
}
| 1,434
| 22.52459
| 81
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/cvc4/Cvc4Solver.java
|
package jkind.solvers.cvc4;
import java.io.IOException;
import java.util.List;
import jkind.JKindException;
import jkind.sexp.Symbol;
import jkind.solvers.smtlib2.SmtLib2Solver;
public class Cvc4Solver extends SmtLib2Solver {
public Cvc4Solver(String scratchBase) {
super(scratchBase);
}
@Override
protected String getSolverName() {
return "CVC4";
}
@Override
protected String[] getSolverOptions() {
return new String[] { "--lang", "smt" };
}
@Override
public void initialize() {
send("(set-option :produce-models true)");
send("(set-option :incremental true)");
send("(set-option :rewrite-divk true)");
send("(set-logic AUFLIRA)");
}
@Override
protected List<Symbol> getUnsatCore(List<Symbol> activationLiterals) {
// CVC4 does not yet support unsat-cores
return activationLiterals;
}
@Override
protected void send(String str) {
scratch(str);
try {
// Some versions of CVC4 require two newlines
// https://github.com/CVC4/CVC4/issues/2720
toSolver.append(str);
toSolver.newLine();
toSolver.newLine();
toSolver.flush();
} catch (IOException e) {
throw new JKindException(
"Unable to write to " + getSolverName() + ", " + "probably due to internal JKind error", e);
}
}
}
| 1,248
| 21.709091
| 97
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/yices2/Yices2Listener.java
|
// Generated from Yices2.g4 by ANTLR 4.4
package jkind.solvers.yices2;
import org.antlr.v4.runtime.misc.NotNull;
import org.antlr.v4.runtime.tree.ParseTreeListener;
/**
* This interface defines a complete listener for a parse tree produced by
* {@link Yices2Parser}.
*/
public interface Yices2Listener extends ParseTreeListener {
/**
* Enter a parse tree produced by the {@code integerNumeric}
* labeled alternative in {@link Yices2Parser#numeric}.
* @param ctx the parse tree
*/
void enterIntegerNumeric(@NotNull Yices2Parser.IntegerNumericContext ctx);
/**
* Exit a parse tree produced by the {@code integerNumeric}
* labeled alternative in {@link Yices2Parser#numeric}.
* @param ctx the parse tree
*/
void exitIntegerNumeric(@NotNull Yices2Parser.IntegerNumericContext ctx);
/**
* Enter a parse tree produced by {@link Yices2Parser#defaultValue}.
* @param ctx the parse tree
*/
void enterDefaultValue(@NotNull Yices2Parser.DefaultValueContext ctx);
/**
* Exit a parse tree produced by {@link Yices2Parser#defaultValue}.
* @param ctx the parse tree
*/
void exitDefaultValue(@NotNull Yices2Parser.DefaultValueContext ctx);
/**
* Enter a parse tree produced by {@link Yices2Parser#type}.
* @param ctx the parse tree
*/
void enterType(@NotNull Yices2Parser.TypeContext ctx);
/**
* Exit a parse tree produced by {@link Yices2Parser#type}.
* @param ctx the parse tree
*/
void exitType(@NotNull Yices2Parser.TypeContext ctx);
/**
* Enter a parse tree produced by {@link Yices2Parser#quotient}.
* @param ctx the parse tree
*/
void enterQuotient(@NotNull Yices2Parser.QuotientContext ctx);
/**
* Exit a parse tree produced by {@link Yices2Parser#quotient}.
* @param ctx the parse tree
*/
void exitQuotient(@NotNull Yices2Parser.QuotientContext ctx);
/**
* Enter a parse tree produced by the {@code negativeInteger}
* labeled alternative in {@link Yices2Parser#integer}.
* @param ctx the parse tree
*/
void enterNegativeInteger(@NotNull Yices2Parser.NegativeIntegerContext ctx);
/**
* Exit a parse tree produced by the {@code negativeInteger}
* labeled alternative in {@link Yices2Parser#integer}.
* @param ctx the parse tree
*/
void exitNegativeInteger(@NotNull Yices2Parser.NegativeIntegerContext ctx);
/**
* Enter a parse tree produced by {@link Yices2Parser#function}.
* @param ctx the parse tree
*/
void enterFunction(@NotNull Yices2Parser.FunctionContext ctx);
/**
* Exit a parse tree produced by {@link Yices2Parser#function}.
* @param ctx the parse tree
*/
void exitFunction(@NotNull Yices2Parser.FunctionContext ctx);
/**
* Enter a parse tree produced by the {@code positiveInteger}
* labeled alternative in {@link Yices2Parser#integer}.
* @param ctx the parse tree
*/
void enterPositiveInteger(@NotNull Yices2Parser.PositiveIntegerContext ctx);
/**
* Exit a parse tree produced by the {@code positiveInteger}
* labeled alternative in {@link Yices2Parser#integer}.
* @param ctx the parse tree
*/
void exitPositiveInteger(@NotNull Yices2Parser.PositiveIntegerContext ctx);
/**
* Enter a parse tree produced by {@link Yices2Parser#variable}.
* @param ctx the parse tree
*/
void enterVariable(@NotNull Yices2Parser.VariableContext ctx);
/**
* Exit a parse tree produced by {@link Yices2Parser#variable}.
* @param ctx the parse tree
*/
void exitVariable(@NotNull Yices2Parser.VariableContext ctx);
/**
* Enter a parse tree produced by {@link Yices2Parser#alias}.
* @param ctx the parse tree
*/
void enterAlias(@NotNull Yices2Parser.AliasContext ctx);
/**
* Exit a parse tree produced by {@link Yices2Parser#alias}.
* @param ctx the parse tree
*/
void exitAlias(@NotNull Yices2Parser.AliasContext ctx);
/**
* Enter a parse tree produced by {@link Yices2Parser#functionValue}.
* @param ctx the parse tree
*/
void enterFunctionValue(@NotNull Yices2Parser.FunctionValueContext ctx);
/**
* Exit a parse tree produced by {@link Yices2Parser#functionValue}.
* @param ctx the parse tree
*/
void exitFunctionValue(@NotNull Yices2Parser.FunctionValueContext ctx);
/**
* Enter a parse tree produced by {@link Yices2Parser#model}.
* @param ctx the parse tree
*/
void enterModel(@NotNull Yices2Parser.ModelContext ctx);
/**
* Exit a parse tree produced by {@link Yices2Parser#model}.
* @param ctx the parse tree
*/
void exitModel(@NotNull Yices2Parser.ModelContext ctx);
/**
* Enter a parse tree produced by {@link Yices2Parser#functionType}.
* @param ctx the parse tree
*/
void enterFunctionType(@NotNull Yices2Parser.FunctionTypeContext ctx);
/**
* Exit a parse tree produced by {@link Yices2Parser#functionType}.
* @param ctx the parse tree
*/
void exitFunctionType(@NotNull Yices2Parser.FunctionTypeContext ctx);
/**
* Enter a parse tree produced by the {@code quotientNumeric}
* labeled alternative in {@link Yices2Parser#numeric}.
* @param ctx the parse tree
*/
void enterQuotientNumeric(@NotNull Yices2Parser.QuotientNumericContext ctx);
/**
* Exit a parse tree produced by the {@code quotientNumeric}
* labeled alternative in {@link Yices2Parser#numeric}.
* @param ctx the parse tree
*/
void exitQuotientNumeric(@NotNull Yices2Parser.QuotientNumericContext ctx);
/**
* Enter a parse tree produced by {@link Yices2Parser#value}.
* @param ctx the parse tree
*/
void enterValue(@NotNull Yices2Parser.ValueContext ctx);
/**
* Exit a parse tree produced by {@link Yices2Parser#value}.
* @param ctx the parse tree
*/
void exitValue(@NotNull Yices2Parser.ValueContext ctx);
}
| 5,633
| 29.128342
| 77
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/yices2/Yices2Model.java
|
package jkind.solvers.yices2;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import jkind.lustre.Function;
import jkind.lustre.Type;
import jkind.lustre.values.Value;
import jkind.results.FunctionTable;
import jkind.solvers.yices.YicesModel;
import jkind.util.Util;
public class Yices2Model extends YicesModel {
private final Map<String, Value> functionDefaultValue = new HashMap<>();
public Yices2Model(Map<String, Type> varTypes, List<Function> functions) {
super(varTypes, functions);
}
public void setFunctionDefaultValue(String name, Value value) {
functionDefaultValue.put(name, value);
}
@Override
public Value evaluateFunction(String name, List<Value> inputs) {
name = getAlias(name);
FunctionTable table = functionTables.get(name);
Value value = table.lookup(inputs);
if (value == null) {
value = functionDefaultValue.get(name);
}
return Util.promoteIfNeeded(value, table.getOutput().type);
}
}
| 963
| 24.368421
| 75
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/yices2/ModelExtractorListener.java
|
package jkind.solvers.yices2;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import jkind.lustre.Function;
import jkind.lustre.NamedType;
import jkind.lustre.Type;
import jkind.lustre.VarDecl;
import jkind.lustre.values.BooleanValue;
import jkind.lustre.values.IntegerValue;
import jkind.lustre.values.RealValue;
import jkind.lustre.values.Value;
import jkind.results.FunctionTable;
import jkind.solvers.yices2.Yices2Parser.AliasContext;
import jkind.solvers.yices2.Yices2Parser.FunctionContext;
import jkind.solvers.yices2.Yices2Parser.FunctionTypeContext;
import jkind.solvers.yices2.Yices2Parser.FunctionValueContext;
import jkind.solvers.yices2.Yices2Parser.IntegerContext;
import jkind.solvers.yices2.Yices2Parser.IntegerNumericContext;
import jkind.solvers.yices2.Yices2Parser.NegativeIntegerContext;
import jkind.solvers.yices2.Yices2Parser.PositiveIntegerContext;
import jkind.solvers.yices2.Yices2Parser.QuotientContext;
import jkind.solvers.yices2.Yices2Parser.QuotientNumericContext;
import jkind.solvers.yices2.Yices2Parser.TypeContext;
import jkind.solvers.yices2.Yices2Parser.ValueContext;
import jkind.solvers.yices2.Yices2Parser.VariableContext;
import jkind.util.BigFraction;
import jkind.util.SexpUtil;
public class ModelExtractorListener extends Yices2BaseListener {
private final Yices2Model model;
public ModelExtractorListener(Map<String, Type> varTypes, List<Function> functions) {
this.model = new Yices2Model(varTypes, functions);
}
public Yices2Model getModel() {
return model;
}
@Override
public void enterAlias(AliasContext ctx) {
model.addAlias(ctx.ID(0).getText(), ctx.ID(1).getText());
}
@Override
public void enterVariable(VariableContext ctx) {
String name = ctx.ID().getText();
Value value = value(ctx.value());
if (SexpUtil.isEncodedFunction(name)) {
// Nullary function value
FunctionTable table = model.getFunctionTable(name);
table.addRow(Collections.emptyList(), value);
} else {
model.addValue(name, value);
}
}
private Value value(ValueContext ctx) {
if (ctx.BOOL() != null) {
return BooleanValue.fromBoolean(ctx.BOOL().getText().equals("true"));
} else if (ctx.numeric() instanceof IntegerNumericContext) {
IntegerNumericContext ictx = (IntegerNumericContext) ctx.numeric();
return new IntegerValue(integer(ictx.integer()));
} else if (ctx.numeric() instanceof QuotientNumericContext) {
QuotientNumericContext qctx = (QuotientNumericContext) ctx.numeric();
qctx.quotient().numeric(0);
return new RealValue(quotient(qctx.quotient()));
} else {
throw new IllegalArgumentException();
}
}
private BigFraction quotient(QuotientContext ctx) {
IntegerNumericContext num = (IntegerNumericContext) ctx.numeric(0);
IntegerNumericContext den = (IntegerNumericContext) ctx.numeric(1);
return new BigFraction(integer(num.integer()), integer(den.integer()));
}
private BigInteger integer(IntegerContext ctx) {
if (ctx instanceof PositiveIntegerContext) {
PositiveIntegerContext pctx = (PositiveIntegerContext) ctx;
return new BigInteger(pctx.INT().getText());
} else if (ctx instanceof NegativeIntegerContext) {
NegativeIntegerContext nctx = (NegativeIntegerContext) ctx;
return new BigInteger(nctx.INT().getText()).negate();
} else {
throw new IllegalArgumentException();
}
}
@Override
public void enterFunction(FunctionContext ctx) {
String name = ctx.ID().getText();
FunctionTable table = model.getFunctionTable(name);
if (table == null) {
FunctionTypeContext typeCtx = ctx.functionType();
int n = typeCtx.type().size() - 1;
List<VarDecl> inputs = new ArrayList<>();
for (int i = 0; i < n; i++) {
inputs.add(new VarDecl("", type(typeCtx.type(i))));
}
VarDecl output = new VarDecl("", type(typeCtx.type(n)));
table = new FunctionTable(name, inputs, output);
model.addFunctionTable(name, table);
}
for (FunctionValueContext valueCtx : ctx.functionValue()) {
int n = valueCtx.value().size() - 1;
List<Value> inputs = new ArrayList<>();
for (int i = 0; i < n; i++) {
inputs.add(value(valueCtx.value(i)));
}
Value output = value(valueCtx.value(n));
table.addRow(inputs, output);
}
if (ctx.defaultValue() != null) {
Value defaultValue = value(ctx.defaultValue().value());
model.setFunctionDefaultValue(name, defaultValue);
}
}
private Type type(TypeContext ctx) {
return NamedType.get(ctx.getText());
}
}
| 4,514
| 32.947368
| 86
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/yices2/Yices2Parser.java
|
// Generated from Yices2.g4 by ANTLR 4.4
package jkind.solvers.yices2;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({ "all", "warnings", "unchecked", "unused", "cast" })
public class Yices2Parser extends Parser {
static {
RuntimeMetaData.checkVersion("4.4", RuntimeMetaData.VERSION);
}
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache();
public static final int T__11 = 1, T__10 = 2, T__9 = 3, T__8 = 4, T__7 = 5, T__6 = 6, T__5 = 7, T__4 = 8, T__3 = 9,
T__2 = 10, T__1 = 11, T__0 = 12, BOOL = 13, INT = 14, ID = 15, WS = 16, ERROR = 17;
public static final String[] tokenNames = { "<INVALID>", "'/'", "'default'", "'type'", "'->'", "'int'",
"'function'", "'('", "')'", "'-'", "'='", "'bool'", "'real'", "BOOL", "INT", "ID", "WS", "ERROR" };
public static final int RULE_model = 0, RULE_alias = 1, RULE_variable = 2, RULE_function = 3, RULE_functionType = 4,
RULE_type = 5, RULE_functionValue = 6, RULE_defaultValue = 7, RULE_value = 8, RULE_integer = 9,
RULE_quotient = 10, RULE_numeric = 11;
public static final String[] ruleNames = { "model", "alias", "variable", "function", "functionType", "type",
"functionValue", "defaultValue", "value", "integer", "quotient", "numeric" };
@Override
public String getGrammarFileName() {
return "Yices2.g4";
}
@Override
public String[] getTokenNames() {
return tokenNames;
}
@Override
public String[] getRuleNames() {
return ruleNames;
}
@Override
public String getSerializedATN() {
return _serializedATN;
}
@Override
public ATN getATN() {
return _ATN;
}
public Yices2Parser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
}
public static class ModelContext extends ParserRuleContext {
public List<AliasContext> alias() {
return getRuleContexts(AliasContext.class);
}
public TerminalNode EOF() {
return getToken(Yices2Parser.EOF, 0);
}
public AliasContext alias(int i) {
return getRuleContext(AliasContext.class, i);
}
public FunctionContext function(int i) {
return getRuleContext(FunctionContext.class, i);
}
public VariableContext variable(int i) {
return getRuleContext(VariableContext.class, i);
}
public List<VariableContext> variable() {
return getRuleContexts(VariableContext.class);
}
public List<FunctionContext> function() {
return getRuleContexts(FunctionContext.class);
}
public ModelContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_model;
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).enterModel(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).exitModel(this);
}
}
public final ModelContext model() throws RecognitionException {
ModelContext _localctx = new ModelContext(_ctx, getState());
enterRule(_localctx, 0, RULE_model);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(27);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
setState(27);
switch (getInterpreter().adaptivePredict(_input, 0, _ctx)) {
case 1: {
setState(24);
alias();
}
break;
case 2: {
setState(25);
variable();
}
break;
case 3: {
setState(26);
function();
}
break;
}
}
setState(29);
_errHandler.sync(this);
_la = _input.LA(1);
} while (_la == T__5);
setState(31);
match(EOF);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class AliasContext extends ParserRuleContext {
public List<TerminalNode> ID() {
return getTokens(Yices2Parser.ID);
}
public TerminalNode ID(int i) {
return getToken(Yices2Parser.ID, i);
}
public AliasContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_alias;
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).enterAlias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).exitAlias(this);
}
}
public final AliasContext alias() throws RecognitionException {
AliasContext _localctx = new AliasContext(_ctx, getState());
enterRule(_localctx, 2, RULE_alias);
try {
enterOuterAlt(_localctx, 1);
{
setState(33);
match(T__5);
setState(34);
match(T__2);
setState(35);
match(ID);
setState(36);
match(ID);
setState(37);
match(T__4);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class VariableContext extends ParserRuleContext {
public TerminalNode ID() {
return getToken(Yices2Parser.ID, 0);
}
public ValueContext value() {
return getRuleContext(ValueContext.class, 0);
}
public VariableContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_variable;
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).enterVariable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).exitVariable(this);
}
}
public final VariableContext variable() throws RecognitionException {
VariableContext _localctx = new VariableContext(_ctx, getState());
enterRule(_localctx, 4, RULE_variable);
try {
enterOuterAlt(_localctx, 1);
{
setState(39);
match(T__5);
setState(40);
match(T__2);
setState(41);
match(ID);
setState(42);
value();
setState(43);
match(T__4);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class FunctionContext extends ParserRuleContext {
public List<FunctionValueContext> functionValue() {
return getRuleContexts(FunctionValueContext.class);
}
public TerminalNode ID() {
return getToken(Yices2Parser.ID, 0);
}
public DefaultValueContext defaultValue() {
return getRuleContext(DefaultValueContext.class, 0);
}
public FunctionTypeContext functionType() {
return getRuleContext(FunctionTypeContext.class, 0);
}
public FunctionValueContext functionValue(int i) {
return getRuleContext(FunctionValueContext.class, i);
}
public FunctionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_function;
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).enterFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).exitFunction(this);
}
}
public final FunctionContext function() throws RecognitionException {
FunctionContext _localctx = new FunctionContext(_ctx, getState());
enterRule(_localctx, 6, RULE_function);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(45);
match(T__5);
setState(46);
match(T__6);
setState(47);
match(ID);
setState(48);
functionType();
setState(52);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input, 2, _ctx);
while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) {
if (_alt == 1) {
{
{
setState(49);
functionValue();
}
}
}
setState(54);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input, 2, _ctx);
}
setState(56);
_la = _input.LA(1);
if (_la == T__5) {
{
setState(55);
defaultValue();
}
}
setState(58);
match(T__4);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class FunctionTypeContext extends ParserRuleContext {
public TypeContext type(int i) {
return getRuleContext(TypeContext.class, i);
}
public List<TypeContext> type() {
return getRuleContexts(TypeContext.class);
}
public FunctionTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_functionType;
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).enterFunctionType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).exitFunctionType(this);
}
}
public final FunctionTypeContext functionType() throws RecognitionException {
FunctionTypeContext _localctx = new FunctionTypeContext(_ctx, getState());
enterRule(_localctx, 8, RULE_functionType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(60);
match(T__5);
setState(61);
match(T__9);
setState(62);
match(T__5);
setState(63);
match(T__8);
setState(67);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__7) | (1L << T__1) | (1L << T__0))) != 0)) {
{
{
setState(64);
type();
}
}
setState(69);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(70);
match(T__4);
setState(71);
match(T__4);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class TypeContext extends ParserRuleContext {
public TypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_type;
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).enterType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).exitType(this);
}
}
public final TypeContext type() throws RecognitionException {
TypeContext _localctx = new TypeContext(_ctx, getState());
enterRule(_localctx, 10, RULE_type);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(73);
_la = _input.LA(1);
if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__7) | (1L << T__1) | (1L << T__0))) != 0))) {
_errHandler.recoverInline(this);
}
consume();
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class FunctionValueContext extends ParserRuleContext {
public TerminalNode ID() {
return getToken(Yices2Parser.ID, 0);
}
public List<ValueContext> value() {
return getRuleContexts(ValueContext.class);
}
public ValueContext value(int i) {
return getRuleContext(ValueContext.class, i);
}
public FunctionValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_functionValue;
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).enterFunctionValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).exitFunctionValue(this);
}
}
public final FunctionValueContext functionValue() throws RecognitionException {
FunctionValueContext _localctx = new FunctionValueContext(_ctx, getState());
enterRule(_localctx, 12, RULE_functionValue);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(75);
match(T__5);
setState(76);
match(T__2);
setState(77);
match(T__5);
setState(78);
match(ID);
setState(80);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(79);
value();
}
}
setState(82);
_errHandler.sync(this);
_la = _input.LA(1);
} while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__5) | (1L << BOOL) | (1L << INT))) != 0));
setState(84);
match(T__4);
setState(85);
value();
setState(86);
match(T__4);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class DefaultValueContext extends ParserRuleContext {
public ValueContext value() {
return getRuleContext(ValueContext.class, 0);
}
public DefaultValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_defaultValue;
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).enterDefaultValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).exitDefaultValue(this);
}
}
public final DefaultValueContext defaultValue() throws RecognitionException {
DefaultValueContext _localctx = new DefaultValueContext(_ctx, getState());
enterRule(_localctx, 14, RULE_defaultValue);
try {
enterOuterAlt(_localctx, 1);
{
setState(88);
match(T__5);
setState(89);
match(T__10);
setState(90);
value();
setState(91);
match(T__4);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class ValueContext extends ParserRuleContext {
public NumericContext numeric() {
return getRuleContext(NumericContext.class, 0);
}
public TerminalNode BOOL() {
return getToken(Yices2Parser.BOOL, 0);
}
public ValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_value;
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).enterValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).exitValue(this);
}
}
public final ValueContext value() throws RecognitionException {
ValueContext _localctx = new ValueContext(_ctx, getState());
enterRule(_localctx, 16, RULE_value);
try {
setState(95);
switch (_input.LA(1)) {
case BOOL:
enterOuterAlt(_localctx, 1); {
setState(93);
match(BOOL);
}
break;
case T__5:
case INT:
enterOuterAlt(_localctx, 2); {
setState(94);
numeric();
}
break;
default:
throw new NoViableAltException(this);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class IntegerContext extends ParserRuleContext {
public IntegerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_integer;
}
public IntegerContext() {
}
public void copyFrom(IntegerContext ctx) {
super.copyFrom(ctx);
}
}
public static class NegativeIntegerContext extends IntegerContext {
public TerminalNode INT() {
return getToken(Yices2Parser.INT, 0);
}
public NegativeIntegerContext(IntegerContext ctx) {
copyFrom(ctx);
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).enterNegativeInteger(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).exitNegativeInteger(this);
}
}
public static class PositiveIntegerContext extends IntegerContext {
public TerminalNode INT() {
return getToken(Yices2Parser.INT, 0);
}
public PositiveIntegerContext(IntegerContext ctx) {
copyFrom(ctx);
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).enterPositiveInteger(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).exitPositiveInteger(this);
}
}
public final IntegerContext integer() throws RecognitionException {
IntegerContext _localctx = new IntegerContext(_ctx, getState());
enterRule(_localctx, 18, RULE_integer);
try {
setState(102);
switch (_input.LA(1)) {
case INT:
_localctx = new PositiveIntegerContext(_localctx);
enterOuterAlt(_localctx, 1); {
setState(97);
match(INT);
}
break;
case T__5:
_localctx = new NegativeIntegerContext(_localctx);
enterOuterAlt(_localctx, 2); {
setState(98);
match(T__5);
setState(99);
match(T__3);
setState(100);
match(INT);
setState(101);
match(T__4);
}
break;
default:
throw new NoViableAltException(this);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class QuotientContext extends ParserRuleContext {
public List<NumericContext> numeric() {
return getRuleContexts(NumericContext.class);
}
public NumericContext numeric(int i) {
return getRuleContext(NumericContext.class, i);
}
public QuotientContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_quotient;
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).enterQuotient(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).exitQuotient(this);
}
}
public final QuotientContext quotient() throws RecognitionException {
QuotientContext _localctx = new QuotientContext(_ctx, getState());
enterRule(_localctx, 20, RULE_quotient);
try {
enterOuterAlt(_localctx, 1);
{
setState(104);
match(T__5);
setState(105);
match(T__11);
setState(106);
numeric();
setState(107);
numeric();
setState(108);
match(T__4);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class NumericContext extends ParserRuleContext {
public NumericContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_numeric;
}
public NumericContext() {
}
public void copyFrom(NumericContext ctx) {
super.copyFrom(ctx);
}
}
public static class IntegerNumericContext extends NumericContext {
public IntegerContext integer() {
return getRuleContext(IntegerContext.class, 0);
}
public IntegerNumericContext(NumericContext ctx) {
copyFrom(ctx);
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).enterIntegerNumeric(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).exitIntegerNumeric(this);
}
}
public static class QuotientNumericContext extends NumericContext {
public QuotientContext quotient() {
return getRuleContext(QuotientContext.class, 0);
}
public QuotientNumericContext(NumericContext ctx) {
copyFrom(ctx);
}
@Override
public void enterRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).enterQuotientNumeric(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if (listener instanceof Yices2Listener)
((Yices2Listener) listener).exitQuotientNumeric(this);
}
}
public final NumericContext numeric() throws RecognitionException {
NumericContext _localctx = new NumericContext(_ctx, getState());
enterRule(_localctx, 22, RULE_numeric);
try {
setState(112);
switch (getInterpreter().adaptivePredict(_input, 8, _ctx)) {
case 1:
_localctx = new IntegerNumericContext(_localctx);
enterOuterAlt(_localctx, 1); {
setState(110);
integer();
}
break;
case 2:
_localctx = new QuotientNumericContext(_localctx);
enterOuterAlt(_localctx, 2); {
setState(111);
quotient();
}
break;
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static final String _serializedATN = "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\23u\4\2\t\2\4\3\t"
+ "\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4"
+ "\f\t\f\4\r\t\r\3\2\3\2\3\2\6\2\36\n\2\r\2\16\2\37\3\2\3\2\3\3\3\3\3\3"
+ "\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\7\5\65\n\5\f"
+ "\5\16\58\13\5\3\5\5\5;\n\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\7\6D\n\6\f\6\16"
+ "\6G\13\6\3\6\3\6\3\6\3\7\3\7\3\b\3\b\3\b\3\b\3\b\6\bS\n\b\r\b\16\bT\3"
+ "\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\n\3\n\5\nb\n\n\3\13\3\13\3\13\3\13"
+ "\3\13\5\13i\n\13\3\f\3\f\3\f\3\f\3\f\3\f\3\r\3\r\5\rs\n\r\3\r\2\2\16\2"
+ "\4\6\b\n\f\16\20\22\24\26\30\2\3\4\2\7\7\r\16r\2\35\3\2\2\2\4#\3\2\2\2"
+ "\6)\3\2\2\2\b/\3\2\2\2\n>\3\2\2\2\fK\3\2\2\2\16M\3\2\2\2\20Z\3\2\2\2\22"
+ "a\3\2\2\2\24h\3\2\2\2\26j\3\2\2\2\30r\3\2\2\2\32\36\5\4\3\2\33\36\5\6"
+ "\4\2\34\36\5\b\5\2\35\32\3\2\2\2\35\33\3\2\2\2\35\34\3\2\2\2\36\37\3\2"
+ "\2\2\37\35\3\2\2\2\37 \3\2\2\2 !\3\2\2\2!\"\7\2\2\3\"\3\3\2\2\2#$\7\t"
+ "\2\2$%\7\f\2\2%&\7\21\2\2&\'\7\21\2\2\'(\7\n\2\2(\5\3\2\2\2)*\7\t\2\2"
+ "*+\7\f\2\2+,\7\21\2\2,-\5\22\n\2-.\7\n\2\2.\7\3\2\2\2/\60\7\t\2\2\60\61"
+ "\7\b\2\2\61\62\7\21\2\2\62\66\5\n\6\2\63\65\5\16\b\2\64\63\3\2\2\2\65"
+ "8\3\2\2\2\66\64\3\2\2\2\66\67\3\2\2\2\67:\3\2\2\28\66\3\2\2\29;\5\20\t"
+ "\2:9\3\2\2\2:;\3\2\2\2;<\3\2\2\2<=\7\n\2\2=\t\3\2\2\2>?\7\t\2\2?@\7\5"
+ "\2\2@A\7\t\2\2AE\7\6\2\2BD\5\f\7\2CB\3\2\2\2DG\3\2\2\2EC\3\2\2\2EF\3\2"
+ "\2\2FH\3\2\2\2GE\3\2\2\2HI\7\n\2\2IJ\7\n\2\2J\13\3\2\2\2KL\t\2\2\2L\r"
+ "\3\2\2\2MN\7\t\2\2NO\7\f\2\2OP\7\t\2\2PR\7\21\2\2QS\5\22\n\2RQ\3\2\2\2"
+ "ST\3\2\2\2TR\3\2\2\2TU\3\2\2\2UV\3\2\2\2VW\7\n\2\2WX\5\22\n\2XY\7\n\2"
+ "\2Y\17\3\2\2\2Z[\7\t\2\2[\\\7\4\2\2\\]\5\22\n\2]^\7\n\2\2^\21\3\2\2\2"
+ "_b\7\17\2\2`b\5\30\r\2a_\3\2\2\2a`\3\2\2\2b\23\3\2\2\2ci\7\20\2\2de\7"
+ "\t\2\2ef\7\13\2\2fg\7\20\2\2gi\7\n\2\2hc\3\2\2\2hd\3\2\2\2i\25\3\2\2\2"
+ "jk\7\t\2\2kl\7\3\2\2lm\5\30\r\2mn\5\30\r\2no\7\n\2\2o\27\3\2\2\2ps\5\24"
+ "\13\2qs\5\26\f\2rp\3\2\2\2rq\3\2\2\2s\31\3\2\2\2\13\35\37\66:ETahr";
public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray());
static {
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
}
}
}
| 25,182
| 24.775844
| 117
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/yices2/Yices2Solver.java
|
package jkind.solvers.yices2;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.antlr.v4.runtime.ANTLRInputStream;
import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.tree.ParseTreeWalker;
import jkind.JKindException;
import jkind.sexp.Symbol;
import jkind.solvers.Model;
import jkind.solvers.SolverParserErrorListener;
import jkind.solvers.smtlib2.SmtLib2Solver;
import jkind.solvers.yices2.Yices2Parser.ModelContext;
public class Yices2Solver extends SmtLib2Solver {
private final boolean linear;
public Yices2Solver(String scratchBase, boolean linear) {
super(scratchBase);
this.linear = linear;
}
@Override
protected String getSolverName() {
return "Yices2";
}
@Override
protected String getSolverExecutable() {
return "yices-smt2";
}
@Override
protected String[] getSolverOptions() {
return new String[] { "--incremental" };
}
@Override
public void initialize() {
send("(set-option :produce-models true)");
if (linear) {
send("(set-option :produce-unsat-cores true)");
send("(set-logic QF_UFLIRA)");
} else {
send("(set-logic QF_UFNIRA)");
}
}
@Override
protected List<Symbol> getUnsatCore(List<Symbol> activationLiterals) {
List<Symbol> unsatCore = new ArrayList<>();
send("(get-unsat-core)");
for (String s : readCore().split(" ")) {
if (!s.isEmpty()) {
unsatCore.add(new Symbol(s.substring(1)));
}
}
return unsatCore;
}
private String readCore() {
String line = "";
try {
line = fromSolver.readLine();
comment(getSolverName() + ": " + line);
} catch (IOException e) {
e.printStackTrace();
}
return line.substring(1, line.length() - 1);
}
@Override
protected Model parseModel(String string) {
CharStream stream = new ANTLRInputStream(string);
Yices2Lexer lexer = new Yices2Lexer(stream);
CommonTokenStream tokens = new CommonTokenStream(lexer);
Yices2Parser parser = new Yices2Parser(tokens);
parser.removeErrorListeners();
parser.addErrorListener(new SolverParserErrorListener());
ModelContext ctx = parser.model();
if (parser.getNumberOfSyntaxErrors() > 0) {
throw new JKindException("Error parsing " + getSolverName() + " output: " + string);
}
ParseTreeWalker walker = new ParseTreeWalker();
ModelExtractorListener extractor = new ModelExtractorListener(varTypes, functions);
walker.walk(extractor, ctx);
return extractor.getModel();
}
}
| 2,484
| 24.885417
| 87
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/yices2/Yices2BaseListener.java
|
// Generated from Yices2.g4 by ANTLR 4.4
package jkind.solvers.yices2;
import org.antlr.v4.runtime.ParserRuleContext;
import org.antlr.v4.runtime.misc.NotNull;
import org.antlr.v4.runtime.tree.ErrorNode;
import org.antlr.v4.runtime.tree.TerminalNode;
/**
* This class provides an empty implementation of {@link Yices2Listener},
* which can be extended to create a listener which only needs to handle a subset
* of the available methods.
*/
public class Yices2BaseListener implements Yices2Listener {
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterIntegerNumeric(@NotNull Yices2Parser.IntegerNumericContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitIntegerNumeric(@NotNull Yices2Parser.IntegerNumericContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterDefaultValue(@NotNull Yices2Parser.DefaultValueContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitDefaultValue(@NotNull Yices2Parser.DefaultValueContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterType(@NotNull Yices2Parser.TypeContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitType(@NotNull Yices2Parser.TypeContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterQuotient(@NotNull Yices2Parser.QuotientContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitQuotient(@NotNull Yices2Parser.QuotientContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterNegativeInteger(@NotNull Yices2Parser.NegativeIntegerContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitNegativeInteger(@NotNull Yices2Parser.NegativeIntegerContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterFunction(@NotNull Yices2Parser.FunctionContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitFunction(@NotNull Yices2Parser.FunctionContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterPositiveInteger(@NotNull Yices2Parser.PositiveIntegerContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitPositiveInteger(@NotNull Yices2Parser.PositiveIntegerContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterVariable(@NotNull Yices2Parser.VariableContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitVariable(@NotNull Yices2Parser.VariableContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterAlias(@NotNull Yices2Parser.AliasContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitAlias(@NotNull Yices2Parser.AliasContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterFunctionValue(@NotNull Yices2Parser.FunctionValueContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitFunctionValue(@NotNull Yices2Parser.FunctionValueContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterModel(@NotNull Yices2Parser.ModelContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitModel(@NotNull Yices2Parser.ModelContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterFunctionType(@NotNull Yices2Parser.FunctionTypeContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitFunctionType(@NotNull Yices2Parser.FunctionTypeContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterQuotientNumeric(@NotNull Yices2Parser.QuotientNumericContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitQuotientNumeric(@NotNull Yices2Parser.QuotientNumericContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterValue(@NotNull Yices2Parser.ValueContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitValue(@NotNull Yices2Parser.ValueContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void enterEveryRule(@NotNull ParserRuleContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void exitEveryRule(@NotNull ParserRuleContext ctx) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void visitTerminal(@NotNull TerminalNode node) {
}
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override
public void visitErrorNode(@NotNull ErrorNode node) {
}
}
| 6,019
| 18.933775
| 85
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/yices2/Yices2Lexer.java
|
// Generated from Yices2.g4 by ANTLR 4.4
package jkind.solvers.yices2;
import org.antlr.v4.runtime.Lexer;
import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.Token;
import org.antlr.v4.runtime.TokenStream;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.misc.*;
@SuppressWarnings({ "all", "warnings", "unchecked", "unused", "cast" })
public class Yices2Lexer extends Lexer {
static {
RuntimeMetaData.checkVersion("4.4", RuntimeMetaData.VERSION);
}
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache();
public static final int T__11 = 1, T__10 = 2, T__9 = 3, T__8 = 4, T__7 = 5, T__6 = 6, T__5 = 7, T__4 = 8, T__3 = 9,
T__2 = 10, T__1 = 11, T__0 = 12, BOOL = 13, INT = 14, ID = 15, WS = 16, ERROR = 17;
public static String[] modeNames = { "DEFAULT_MODE" };
public static final String[] tokenNames = { "'\\u0000'", "'\\u0001'", "'\\u0002'", "'\\u0003'", "'\\u0004'",
"'\\u0005'", "'\\u0006'", "'\\u0007'", "'\b'", "'\t'", "'\n'", "'\\u000B'", "'\f'", "'\r'", "'\\u000E'",
"'\\u000F'", "'\\u0010'", "'\\u0011'" };
public static final String[] ruleNames = { "T__11", "T__10", "T__9", "T__8", "T__7", "T__6", "T__5", "T__4", "T__3",
"T__2", "T__1", "T__0", "BOOL", "DIGIT", "SYMBOL", "INT", "ID", "WS", "ERROR" };
public Yices2Lexer(CharStream input) {
super(input);
_interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
}
@Override
public String getGrammarFileName() {
return "Yices2.g4";
}
@Override
public String[] getTokenNames() {
return tokenNames;
}
@Override
public String[] getRuleNames() {
return ruleNames;
}
@Override
public String getSerializedATN() {
return _serializedATN;
}
@Override
public String[] getModeNames() {
return modeNames;
}
@Override
public ATN getATN() {
return _ATN;
}
public static final String _serializedATN = "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\2\23\177\b\1\4\2\t"
+ "\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"
+ "\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"
+ "\4\23\t\23\4\24\t\24\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3"
+ "\4\3\4\3\4\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7"
+ "\3\7\3\b\3\b\3\t\3\t\3\n\3\n\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\r\3\r\3\r"
+ "\3\r\3\r\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\5\16d\n\16\3\17"
+ "\3\17\3\20\3\20\3\21\6\21k\n\21\r\21\16\21l\3\22\3\22\3\22\7\22r\n\22"
+ "\f\22\16\22u\13\22\3\23\6\23x\n\23\r\23\16\23y\3\23\3\23\3\24\3\24\2\2"
+ "\25\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n\23\13\25\f\27\r\31\16\33\17\35"
+ "\2\37\2!\20#\21%\22\'\23\3\2\5\3\2\62;\b\2##%\'\60\60Bac|\u0080\u0080"
+ "\5\2\13\f\16\17\"\"\u0081\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2"
+ "\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2"
+ "\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2!\3\2\2\2\2#\3\2\2"
+ "\2\2%\3\2\2\2\2\'\3\2\2\2\3)\3\2\2\2\5+\3\2\2\2\7\63\3\2\2\2\t8\3\2\2"
+ "\2\13;\3\2\2\2\r?\3\2\2\2\17H\3\2\2\2\21J\3\2\2\2\23L\3\2\2\2\25N\3\2"
+ "\2\2\27P\3\2\2\2\31U\3\2\2\2\33c\3\2\2\2\35e\3\2\2\2\37g\3\2\2\2!j\3\2"
+ "\2\2#n\3\2\2\2%w\3\2\2\2\'}\3\2\2\2)*\7\61\2\2*\4\3\2\2\2+,\7f\2\2,-\7"
+ "g\2\2-.\7h\2\2./\7c\2\2/\60\7w\2\2\60\61\7n\2\2\61\62\7v\2\2\62\6\3\2"
+ "\2\2\63\64\7v\2\2\64\65\7{\2\2\65\66\7r\2\2\66\67\7g\2\2\67\b\3\2\2\2"
+ "89\7/\2\29:\7@\2\2:\n\3\2\2\2;<\7k\2\2<=\7p\2\2=>\7v\2\2>\f\3\2\2\2?@"
+ "\7h\2\2@A\7w\2\2AB\7p\2\2BC\7e\2\2CD\7v\2\2DE\7k\2\2EF\7q\2\2FG\7p\2\2"
+ "G\16\3\2\2\2HI\7*\2\2I\20\3\2\2\2JK\7+\2\2K\22\3\2\2\2LM\7/\2\2M\24\3"
+ "\2\2\2NO\7?\2\2O\26\3\2\2\2PQ\7d\2\2QR\7q\2\2RS\7q\2\2ST\7n\2\2T\30\3"
+ "\2\2\2UV\7t\2\2VW\7g\2\2WX\7c\2\2XY\7n\2\2Y\32\3\2\2\2Z[\7v\2\2[\\\7t"
+ "\2\2\\]\7w\2\2]d\7g\2\2^_\7h\2\2_`\7c\2\2`a\7n\2\2ab\7u\2\2bd\7g\2\2c"
+ "Z\3\2\2\2c^\3\2\2\2d\34\3\2\2\2ef\t\2\2\2f\36\3\2\2\2gh\t\3\2\2h \3\2"
+ "\2\2ik\5\35\17\2ji\3\2\2\2kl\3\2\2\2lj\3\2\2\2lm\3\2\2\2m\"\3\2\2\2ns"
+ "\5\37\20\2or\5\37\20\2pr\5\35\17\2qo\3\2\2\2qp\3\2\2\2ru\3\2\2\2sq\3\2"
+ "\2\2st\3\2\2\2t$\3\2\2\2us\3\2\2\2vx\t\4\2\2wv\3\2\2\2xy\3\2\2\2yw\3\2"
+ "\2\2yz\3\2\2\2z{\3\2\2\2{|\b\23\2\2|&\3\2\2\2}~\13\2\2\2~(\3\2\2\2\b\2" + "clqsy\3\b\2\2";
public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray());
static {
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
}
}
}
| 4,735
| 44.538462
| 117
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/z3/Z3Solver.java
|
package jkind.solvers.z3;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import jkind.sexp.Cons;
import jkind.sexp.Sexp;
import jkind.sexp.Symbol;
import jkind.solvers.MaxSatSolver;
import jkind.solvers.Result;
import jkind.solvers.SatResult;
import jkind.solvers.UnknownResult;
import jkind.solvers.UnsatResult;
import jkind.solvers.smtlib2.SmtLib2Solver;
import jkind.solvers.smtlib2.SolverOutOfMemoryException;
public class Z3Solver extends SmtLib2Solver implements MaxSatSolver {
private final boolean linear;
private int actCount = 1;
public Z3Solver(String scratchBase, boolean linear) {
super(scratchBase);
this.linear = linear;
}
@Override
protected String getSolverName() {
return "Z3";
}
@Override
protected String[] getSolverOptions() {
return new String[] { "-smt2", "-in" };
}
@Override
public void initialize() {
setOption("produce-models", true);
setOption("produce-unsat-cores", true);
setOption("smt.core.minimize", true);
setOption("sat.core.minimize", true);
// The following option can be added
// when the reported bugs in Z3 resurfaces:
// https://github.com/Z3Prover/z3/issues/158
// setOption("smt.core.validate", true);
}
public void setOption(String option, boolean value) {
send("(set-option :" + option + " " + value + ")");
}
@Override
public Result query(Sexp sexp) {
Result result;
if (linear) {
Symbol literal = createActivationLiteral("act", actCount++);
send(new Cons("assert", new Cons("=>", literal, new Cons("not", sexp))));
send(new Cons("check-sat", literal));
} else {
push();
send(new Cons("assert", new Cons("not", sexp)));
send(new Cons("check-sat"));
}
try {
String status = readFromSolver();
if (isSat(status)) {
send("(get-model)");
result = new SatResult(parseModel(readFromSolver()));
} else if (isUnsat(status)) {
result = new UnsatResult();
} else {
// Even for unknown we can sometimes get a partial model
send("(get-model)");
String content = readFromSolver();
if (content == null) {
return new UnknownResult();
} else {
result = new UnknownResult(parseModel(content));
}
}
} catch (SolverOutOfMemoryException e) {
return new UnknownResult();
}
if (!linear) {
pop();
}
return result;
}
@Override
public Result quickCheckSat(List<Symbol> activationLiterals) {
send(new Cons("check-sat", activationLiterals));
String status = readFromSolver();
if (isSat(status)) {
return new SatResult();
} else if (isUnsat(status)) {
return new UnsatResult(getUnsatCore(activationLiterals));
} else {
return new UnknownResult();
}
}
public Result checkMaximal() {
send("(set-option :sat.phase always_true)");
send("(check-sat-using sat)");
String status = readFromSolver();
if (isSat(status)) {
send("(get-model)");
return new SatResult(parseModel(readFromSolver()));
} else if (isUnsat(status)) {
return new UnsatResult();
} else {
return new UnknownResult();
}
}
public Result checkMinimal() {
send("(set-option :sat.phase always_false)");
send("(check-sat-using sat)");
String status = readFromSolver();
if (isSat(status)) {
send("(get-model)");
return new SatResult(parseModel(readFromSolver()));
} else if (isUnsat(status)) {
return new UnsatResult();
} else {
return new UnknownResult();
}
}
public Result checkValuation(List<Symbol> positiveLits, List<Symbol> negativeLits, boolean getModel) {
String arg = "(check-sat ";
for (Symbol s : positiveLits) {
arg += s.toString() + " ";
}
for (Symbol s : negativeLits) {
arg += "(not " + s.toString() + ") ";
}
arg += ")";
send(arg);
String status = readFromSolver();
if (isSat(status)) {
if (getModel) {
send("(get-model)");
return new SatResult(parseModel(readFromSolver()));
} else {
return new SatResult();
}
} else if (isUnsat(status)) {
return new UnsatResult();
} else {
return new UnknownResult();
}
}
/**
* similar to quickCheckSat, but focused on
* 1- either the SAT model or unsat-core
* 2- or just the return Type of Result
*/
public Result checkSat(List<Symbol> activationLiterals, boolean getModel, boolean getCore) {
send(new Cons("check-sat", activationLiterals));
String status = readFromSolver();
if (isSat(status)) {
if (getModel) {
send("(get-model)");
return new SatResult(parseModel(readFromSolver()));
} else {
return new SatResult();
}
} else if (isUnsat(status)) {
if (getCore) {
return new UnsatResult(getUnsatCore(activationLiterals));
} else {
return new UnsatResult();
}
} else {
return new UnknownResult();
}
}
@Override
protected List<Symbol> getUnsatCore(List<Symbol> activationLiterals) {
List<Symbol> unsatCore = new ArrayList<>();
send("(get-unsat-core)");
for (String s : readCore().split(" ")) {
if (!s.isEmpty()) {
unsatCore.add(new Symbol(s));
}
}
return unsatCore;
}
private String readCore() {
String line = "";
try {
line = fromSolver.readLine();
comment(getSolverName() + ": " + line);
} catch (IOException e) {
e.printStackTrace();
}
return line.substring(1, line.length() - 1);
}
public Result realizabilityQuery(Sexp outputs, Sexp transition, Sexp properties, int timeoutMs) {
push();
if (timeoutMs > 0) {
send(new Cons("set-option", new Symbol(":timeout"), Sexp.fromInt(timeoutMs)));
}
Sexp query = new Cons("not", new Cons("and", transition, properties));
if (outputs != null) {
query = new Cons("forall", outputs, query);
}
assertSexp(query);
send(new Cons("check-sat"));
String status = readFromSolver();
if (isSat(status)) {
send("(get-model)");
pop();
return new SatResult(parseModel(readFromSolver()));
} else if (isUnsat(status)) {
pop();
return new UnsatResult();
} else {
pop();
return new UnknownResult();
}
}
public Result realizabilityQuery(Sexp outputs, Sexp transition, Sexp properties) {
return realizabilityQuery(outputs, transition, properties, 0);
}
@Override
public void assertSoft(Sexp sexp) {
send(new Cons("assert-soft", sexp));
}
@Override
public Result maxsatQuery(Sexp query) {
return query(query);
}
}
| 6,299
| 23.418605
| 103
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/mathsat/MathSatSolver.java
|
package jkind.solvers.mathsat;
import static java.util.stream.Collectors.toList;
import java.util.List;
import org.antlr.v4.runtime.ANTLRInputStream;
import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.CommonTokenStream;
import jkind.JKindException;
import jkind.lustre.BinaryExpr;
import jkind.lustre.BinaryOp;
import jkind.lustre.Expr;
import jkind.lustre.visitors.ExprConjunctiveVisitor;
import jkind.sexp.Cons;
import jkind.sexp.Sexp;
import jkind.sexp.Symbol;
import jkind.solvers.Model;
import jkind.solvers.Result;
import jkind.solvers.SatResult;
import jkind.solvers.SolverParserErrorListener;
import jkind.solvers.UnknownResult;
import jkind.solvers.UnsatResult;
import jkind.solvers.mathsat.MathSatParser.ModelContext;
import jkind.solvers.mathsat.MathSatParser.UnsatAssumptionsContext;
import jkind.solvers.smtlib2.SmtLib2Solver;
public class MathSatSolver extends SmtLib2Solver {
public MathSatSolver(String scratchBase) {
super(scratchBase);
}
@Override
protected String getSolverName() {
return "MathSAT";
}
@Override
public void initialize() {
send("(set-option :produce-models true)");
send("(set-option :produce-unsat-cores true)");
}
private int actCount = 1;
@Override
public Result query(Sexp sexp) {
Result result = null;
Symbol actLit = createActivationLiteral("act", actCount++);
send(new Cons("assert", new Cons("=>", actLit, new Cons("not", sexp))));
send(new Cons("check-sat-assumptions", new Cons(actLit)));
String status = readFromSolver();
if (isSat(status)) {
send("(get-model)");
result = new SatResult(parseMathSatModel(readFromSolver()));
} else if (isUnsat(status)) {
result = new UnsatResult();
} else {
throw new IllegalArgumentException("Unknown result: " + result);
}
return result;
}
@Override
protected Result quickCheckSat(List<Symbol> activationLiterals) {
if (activationLiterals.isEmpty()) {
send(new Cons("check-sat"));
} else {
Symbol head = activationLiterals.get(0);
List<Symbol> tail = activationLiterals.subList(1, activationLiterals.size());
send(new Cons("check-sat-assumptions", new Cons(head, tail)));
}
String status = readFromSolver();
if (isSat(status)) {
return new SatResult();
} else if (isUnsat(status)) {
return new UnsatResult(getUnsatCore(activationLiterals));
} else {
return new UnknownResult();
}
}
@Override
protected List<Symbol> getUnsatCore(List<Symbol> activationLiterals) {
send(new Cons("get-unsat-assumptions"));
return parseUnsatAssumptions(readFromSolver());
}
protected Model parseMathSatModel(String string) {
MathSatParser parser = getParser(string);
ModelContext ctx = parser.model();
ensureNoParseError(parser, string);
return ModelExtractor.getModel(ctx, varTypes, functions);
}
private List<Symbol> parseUnsatAssumptions(String string) {
MathSatParser parser = getParser(string);
UnsatAssumptionsContext ctx = parser.unsatAssumptions();
ensureNoParseError(parser, string);
return ctx.symbol().stream().map(sctx -> new Symbol(sctx.getText())).collect(toList());
}
private MathSatParser getParser(String string) {
CharStream stream = new ANTLRInputStream(string);
MathSatLexer lexer = new MathSatLexer(stream);
CommonTokenStream tokens = new CommonTokenStream(lexer);
MathSatParser parser = new MathSatParser(tokens);
parser.removeErrorListeners();
parser.addErrorListener(new SolverParserErrorListener());
return parser;
}
private void ensureNoParseError(MathSatParser parser, String string) {
if (parser.getNumberOfSyntaxErrors() > 0) {
throw new JKindException("Error parsing " + getSolverName() + " output: " + string);
}
}
@Override
public boolean supports(Expr expr) {
return expr.accept(new ExprConjunctiveVisitor() {
@Override
public Boolean visit(BinaryExpr e) {
return e.op != BinaryOp.INT_DIVIDE && e.op != BinaryOp.MODULUS && super.visit(e);
}
});
}
}
| 3,943
| 28.878788
| 89
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/mathsat/MathSatParser.java
|
// Generated from MathSat.g4 by ANTLR 4.4
package jkind.solvers.mathsat;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({ "all", "warnings", "unchecked", "unused", "cast" })
public class MathSatParser extends Parser {
static {
RuntimeMetaData.checkVersion("4.4", RuntimeMetaData.VERSION);
}
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache();
public static final int T__4 = 1, T__3 = 2, T__2 = 3, T__1 = 4, T__0 = 5, BOOL = 6, INT = 7, ID = 8, WS = 9,
ERROR = 10;
public static final String[] tokenNames = { "<INVALID>", "'/'", "'('", "')'", "'|'", "'-'", "BOOL", "INT", "ID",
"WS", "ERROR" };
public static final int RULE_model = 0, RULE_assignment = 1, RULE_unsatAssumptions = 2, RULE_body = 3, RULE_fn = 4,
RULE_fnApp = 5, RULE_symbol = 6, RULE_id = 7, RULE_qid = 8;
public static final String[] ruleNames = { "model", "assignment", "unsatAssumptions", "body", "fn", "fnApp",
"symbol", "id", "qid" };
@Override
public String getGrammarFileName() {
return "MathSat.g4";
}
@Override
public String[] getTokenNames() {
return tokenNames;
}
@Override
public String[] getRuleNames() {
return ruleNames;
}
@Override
public String getSerializedATN() {
return _serializedATN;
}
@Override
public ATN getATN() {
return _ATN;
}
public MathSatParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
}
public static class ModelContext extends ParserRuleContext {
public List<AssignmentContext> assignment() {
return getRuleContexts(AssignmentContext.class);
}
public TerminalNode EOF() {
return getToken(MathSatParser.EOF, 0);
}
public AssignmentContext assignment(int i) {
return getRuleContext(AssignmentContext.class, i);
}
public ModelContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_model;
}
}
public final ModelContext model() throws RecognitionException {
ModelContext _localctx = new ModelContext(_ctx, getState());
enterRule(_localctx, 0, RULE_model);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(18);
match(T__3);
setState(22);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la == T__3) {
{
{
setState(19);
assignment();
}
}
setState(24);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(25);
match(T__2);
setState(26);
match(EOF);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class AssignmentContext extends ParserRuleContext {
public IdContext id() {
return getRuleContext(IdContext.class, 0);
}
public FnAppContext fnApp() {
return getRuleContext(FnAppContext.class, 0);
}
public BodyContext body() {
return getRuleContext(BodyContext.class, 0);
}
public AssignmentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_assignment;
}
}
public final AssignmentContext assignment() throws RecognitionException {
AssignmentContext _localctx = new AssignmentContext(_ctx, getState());
enterRule(_localctx, 2, RULE_assignment);
try {
enterOuterAlt(_localctx, 1);
{
setState(28);
match(T__3);
setState(31);
switch (_input.LA(1)) {
case T__1:
case ID: {
setState(29);
id();
}
break;
case T__3: {
setState(30);
fnApp();
}
break;
default:
throw new NoViableAltException(this);
}
setState(33);
body();
setState(34);
match(T__2);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class UnsatAssumptionsContext extends ParserRuleContext {
public SymbolContext symbol(int i) {
return getRuleContext(SymbolContext.class, i);
}
public List<SymbolContext> symbol() {
return getRuleContexts(SymbolContext.class);
}
public UnsatAssumptionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_unsatAssumptions;
}
}
public final UnsatAssumptionsContext unsatAssumptions() throws RecognitionException {
UnsatAssumptionsContext _localctx = new UnsatAssumptionsContext(_ctx, getState());
enterRule(_localctx, 4, RULE_unsatAssumptions);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(36);
match(T__3);
setState(40);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0
&& ((1L << _la) & ((1L << T__1) | (1L << BOOL) | (1L << INT) | (1L << ID))) != 0)) {
{
{
setState(37);
symbol();
}
}
setState(42);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(43);
match(T__2);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class BodyContext extends ParserRuleContext {
public BodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_body;
}
public BodyContext() {
}
public void copyFrom(BodyContext ctx) {
super.copyFrom(ctx);
}
}
public static class ConsBodyContext extends BodyContext {
public BodyContext body(int i) {
return getRuleContext(BodyContext.class, i);
}
public FnContext fn() {
return getRuleContext(FnContext.class, 0);
}
public List<BodyContext> body() {
return getRuleContexts(BodyContext.class);
}
public ConsBodyContext(BodyContext ctx) {
copyFrom(ctx);
}
}
public static class SymbolBodyContext extends BodyContext {
public SymbolContext symbol() {
return getRuleContext(SymbolContext.class, 0);
}
public SymbolBodyContext(BodyContext ctx) {
copyFrom(ctx);
}
}
public final BodyContext body() throws RecognitionException {
BodyContext _localctx = new BodyContext(_ctx, getState());
enterRule(_localctx, 6, RULE_body);
int _la;
try {
setState(56);
switch (_input.LA(1)) {
case T__1:
case BOOL:
case INT:
case ID:
_localctx = new SymbolBodyContext(_localctx);
enterOuterAlt(_localctx, 1); {
setState(45);
symbol();
}
break;
case T__3:
_localctx = new ConsBodyContext(_localctx);
enterOuterAlt(_localctx, 2); {
setState(46);
match(T__3);
setState(47);
fn();
setState(51);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la)
& ((1L << T__3) | (1L << T__1) | (1L << BOOL) | (1L << INT) | (1L << ID))) != 0)) {
{
{
setState(48);
body();
}
}
setState(53);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(54);
match(T__2);
}
break;
default:
throw new NoViableAltException(this);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class FnContext extends ParserRuleContext {
public FnContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_fn;
}
}
public final FnContext fn() throws RecognitionException {
FnContext _localctx = new FnContext(_ctx, getState());
enterRule(_localctx, 8, RULE_fn);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(58);
_la = _input.LA(1);
if (!(_la == T__4 || _la == T__0)) {
_errHandler.recoverInline(this);
}
consume();
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class FnAppContext extends ParserRuleContext {
public BodyContext body(int i) {
return getRuleContext(BodyContext.class, i);
}
public IdContext id() {
return getRuleContext(IdContext.class, 0);
}
public List<BodyContext> body() {
return getRuleContexts(BodyContext.class);
}
public FnAppContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_fnApp;
}
}
public final FnAppContext fnApp() throws RecognitionException {
FnAppContext _localctx = new FnAppContext(_ctx, getState());
enterRule(_localctx, 10, RULE_fnApp);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(60);
match(T__3);
setState(61);
id();
setState(63);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(62);
body();
}
}
setState(65);
_errHandler.sync(this);
_la = _input.LA(1);
} while ((((_la) & ~0x3f) == 0 && ((1L << _la)
& ((1L << T__3) | (1L << T__1) | (1L << BOOL) | (1L << INT) | (1L << ID))) != 0));
setState(67);
match(T__2);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class SymbolContext extends ParserRuleContext {
public TerminalNode BOOL() {
return getToken(MathSatParser.BOOL, 0);
}
public IdContext id() {
return getRuleContext(IdContext.class, 0);
}
public TerminalNode INT() {
return getToken(MathSatParser.INT, 0);
}
public SymbolContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_symbol;
}
}
public final SymbolContext symbol() throws RecognitionException {
SymbolContext _localctx = new SymbolContext(_ctx, getState());
enterRule(_localctx, 12, RULE_symbol);
try {
setState(72);
switch (_input.LA(1)) {
case T__1:
case ID:
enterOuterAlt(_localctx, 1); {
setState(69);
id();
}
break;
case BOOL:
enterOuterAlt(_localctx, 2); {
setState(70);
match(BOOL);
}
break;
case INT:
enterOuterAlt(_localctx, 3); {
setState(71);
match(INT);
}
break;
default:
throw new NoViableAltException(this);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class IdContext extends ParserRuleContext {
public TerminalNode ID() {
return getToken(MathSatParser.ID, 0);
}
public QidContext qid() {
return getRuleContext(QidContext.class, 0);
}
public IdContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_id;
}
}
public final IdContext id() throws RecognitionException {
IdContext _localctx = new IdContext(_ctx, getState());
enterRule(_localctx, 14, RULE_id);
try {
setState(76);
switch (_input.LA(1)) {
case T__1:
enterOuterAlt(_localctx, 1); {
setState(74);
qid();
}
break;
case ID:
enterOuterAlt(_localctx, 2); {
setState(75);
match(ID);
}
break;
default:
throw new NoViableAltException(this);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static class QidContext extends ParserRuleContext {
public TerminalNode ID() {
return getToken(MathSatParser.ID, 0);
}
public QidContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_qid;
}
}
public final QidContext qid() throws RecognitionException {
QidContext _localctx = new QidContext(_ctx, getState());
enterRule(_localctx, 16, RULE_qid);
try {
enterOuterAlt(_localctx, 1);
{
setState(78);
match(T__1);
setState(79);
match(ID);
setState(80);
match(T__1);
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
public static final String _serializedATN = "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\fU\4\2\t\2\4\3\t"
+ "\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\3\2\3\2\7\2"
+ "\27\n\2\f\2\16\2\32\13\2\3\2\3\2\3\2\3\3\3\3\3\3\5\3\"\n\3\3\3\3\3\3\3"
+ "\3\4\3\4\7\4)\n\4\f\4\16\4,\13\4\3\4\3\4\3\5\3\5\3\5\3\5\7\5\64\n\5\f"
+ "\5\16\5\67\13\5\3\5\3\5\5\5;\n\5\3\6\3\6\3\7\3\7\3\7\6\7B\n\7\r\7\16\7"
+ "C\3\7\3\7\3\b\3\b\3\b\5\bK\n\b\3\t\3\t\5\tO\n\t\3\n\3\n\3\n\3\n\3\n\2"
+ "\2\13\2\4\6\b\n\f\16\20\22\2\3\4\2\3\3\7\7T\2\24\3\2\2\2\4\36\3\2\2\2"
+ "\6&\3\2\2\2\b:\3\2\2\2\n<\3\2\2\2\f>\3\2\2\2\16J\3\2\2\2\20N\3\2\2\2\22"
+ "P\3\2\2\2\24\30\7\4\2\2\25\27\5\4\3\2\26\25\3\2\2\2\27\32\3\2\2\2\30\26"
+ "\3\2\2\2\30\31\3\2\2\2\31\33\3\2\2\2\32\30\3\2\2\2\33\34\7\5\2\2\34\35"
+ "\7\2\2\3\35\3\3\2\2\2\36!\7\4\2\2\37\"\5\20\t\2 \"\5\f\7\2!\37\3\2\2\2"
+ "! \3\2\2\2\"#\3\2\2\2#$\5\b\5\2$%\7\5\2\2%\5\3\2\2\2&*\7\4\2\2\')\5\16"
+ "\b\2(\'\3\2\2\2),\3\2\2\2*(\3\2\2\2*+\3\2\2\2+-\3\2\2\2,*\3\2\2\2-.\7"
+ "\5\2\2.\7\3\2\2\2/;\5\16\b\2\60\61\7\4\2\2\61\65\5\n\6\2\62\64\5\b\5\2"
+ "\63\62\3\2\2\2\64\67\3\2\2\2\65\63\3\2\2\2\65\66\3\2\2\2\668\3\2\2\2\67"
+ "\65\3\2\2\289\7\5\2\29;\3\2\2\2:/\3\2\2\2:\60\3\2\2\2;\t\3\2\2\2<=\t\2"
+ "\2\2=\13\3\2\2\2>?\7\4\2\2?A\5\20\t\2@B\5\b\5\2A@\3\2\2\2BC\3\2\2\2CA"
+ "\3\2\2\2CD\3\2\2\2DE\3\2\2\2EF\7\5\2\2F\r\3\2\2\2GK\5\20\t\2HK\7\b\2\2"
+ "IK\7\t\2\2JG\3\2\2\2JH\3\2\2\2JI\3\2\2\2K\17\3\2\2\2LO\5\22\n\2MO\7\n"
+ "\2\2NL\3\2\2\2NM\3\2\2\2O\21\3\2\2\2PQ\7\6\2\2QR\7\n\2\2RS\7\6\2\2S\23" + "\3\2\2\2\n\30!*\65:CJN";
public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray());
static {
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
}
}
}
| 15,046
| 23.506515
| 116
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/mathsat/MathSatLexer.java
|
// Generated from MathSat.g4 by ANTLR 4.4
package jkind.solvers.mathsat;
import org.antlr.v4.runtime.Lexer;
import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.Token;
import org.antlr.v4.runtime.TokenStream;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.misc.*;
@SuppressWarnings({ "all", "warnings", "unchecked", "unused", "cast" })
public class MathSatLexer extends Lexer {
static {
RuntimeMetaData.checkVersion("4.4", RuntimeMetaData.VERSION);
}
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache();
public static final int T__4 = 1, T__3 = 2, T__2 = 3, T__1 = 4, T__0 = 5, BOOL = 6, INT = 7, ID = 8, WS = 9,
ERROR = 10;
public static String[] modeNames = { "DEFAULT_MODE" };
public static final String[] tokenNames = { "'\\u0000'", "'\\u0001'", "'\\u0002'", "'\\u0003'", "'\\u0004'",
"'\\u0005'", "'\\u0006'", "'\\u0007'", "'\b'", "'\t'", "'\n'" };
public static final String[] ruleNames = { "T__4", "T__3", "T__2", "T__1", "T__0", "BOOL", "DIGIT", "SYMBOL", "INT",
"ID", "WS", "ERROR" };
public MathSatLexer(CharStream input) {
super(input);
_interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
}
@Override
public String getGrammarFileName() {
return "MathSat.g4";
}
@Override
public String[] getTokenNames() {
return tokenNames;
}
@Override
public String[] getRuleNames() {
return ruleNames;
}
@Override
public String getSerializedATN() {
return _serializedATN;
}
@Override
public String[] getModeNames() {
return modeNames;
}
@Override
public ATN getATN() {
return _ATN;
}
public static final String _serializedATN = "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\2\fJ\b\1\4\2\t\2\4"
+ "\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"
+ "\13\4\f\t\f\4\r\t\r\3\2\3\2\3\3\3\3\3\4\3\4\3\5\3\5\3\6\3\6\3\7\3\7\3"
+ "\7\3\7\3\7\3\7\3\7\3\7\3\7\5\7/\n\7\3\b\3\b\3\t\3\t\3\n\6\n\66\n\n\r\n"
+ "\16\n\67\3\13\3\13\3\13\7\13=\n\13\f\13\16\13@\13\13\3\f\6\fC\n\f\r\f"
+ "\16\fD\3\f\3\f\3\r\3\r\2\2\16\3\3\5\4\7\5\t\6\13\7\r\b\17\2\21\2\23\t"
+ "\25\n\27\13\31\f\3\2\5\3\2\62;\b\2##%\'\60\60Bac|\u0080\u0080\5\2\13\f"
+ "\16\17\"\"L\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2"
+ "\2\2\r\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\3\33"
+ "\3\2\2\2\5\35\3\2\2\2\7\37\3\2\2\2\t!\3\2\2\2\13#\3\2\2\2\r.\3\2\2\2\17"
+ "\60\3\2\2\2\21\62\3\2\2\2\23\65\3\2\2\2\259\3\2\2\2\27B\3\2\2\2\31H\3"
+ "\2\2\2\33\34\7\61\2\2\34\4\3\2\2\2\35\36\7*\2\2\36\6\3\2\2\2\37 \7+\2"
+ "\2 \b\3\2\2\2!\"\7~\2\2\"\n\3\2\2\2#$\7/\2\2$\f\3\2\2\2%&\7v\2\2&\'\7"
+ "t\2\2\'(\7w\2\2(/\7g\2\2)*\7h\2\2*+\7c\2\2+,\7n\2\2,-\7u\2\2-/\7g\2\2"
+ ".%\3\2\2\2.)\3\2\2\2/\16\3\2\2\2\60\61\t\2\2\2\61\20\3\2\2\2\62\63\t\3"
+ "\2\2\63\22\3\2\2\2\64\66\5\17\b\2\65\64\3\2\2\2\66\67\3\2\2\2\67\65\3"
+ "\2\2\2\678\3\2\2\28\24\3\2\2\29>\5\21\t\2:=\5\21\t\2;=\5\17\b\2<:\3\2"
+ "\2\2<;\3\2\2\2=@\3\2\2\2><\3\2\2\2>?\3\2\2\2?\26\3\2\2\2@>\3\2\2\2AC\t"
+ "\4\2\2BA\3\2\2\2CD\3\2\2\2DB\3\2\2\2DE\3\2\2\2EF\3\2\2\2FG\b\f\2\2G\30"
+ "\3\2\2\2HI\13\2\2\2I\32\3\2\2\2\b\2.\67<>D\3\b\2\2";
public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray());
static {
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
}
}
}
| 3,629
| 38.456522
| 117
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/mathsat/ModelExtractor.java
|
package jkind.solvers.mathsat;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import jkind.lustre.Function;
import jkind.lustre.Type;
import jkind.lustre.values.Value;
import jkind.results.FunctionTable;
import jkind.sexp.Cons;
import jkind.sexp.Sexp;
import jkind.sexp.Symbol;
import jkind.solvers.mathsat.MathSatParser.AssignmentContext;
import jkind.solvers.mathsat.MathSatParser.BodyContext;
import jkind.solvers.mathsat.MathSatParser.ConsBodyContext;
import jkind.solvers.mathsat.MathSatParser.FnAppContext;
import jkind.solvers.mathsat.MathSatParser.IdContext;
import jkind.solvers.mathsat.MathSatParser.ModelContext;
import jkind.solvers.mathsat.MathSatParser.SymbolBodyContext;
import jkind.solvers.smtlib2.Quoting;
import jkind.solvers.smtlib2.SexpEvaluator;
import jkind.solvers.smtlib2.SmtLib2Model;
public class ModelExtractor {
public static SmtLib2Model getModel(ModelContext ctx, Map<String, Type> varTypes, List<Function> functions) {
SmtLib2Model model = new SmtLib2Model(varTypes, functions);
for (AssignmentContext assignCtx : ctx.assignment()) {
walkAssign(assignCtx, model);
}
return model;
}
public static void walkAssign(AssignmentContext assignCtx, SmtLib2Model model) {
if (assignCtx.id() != null) {
String var = getId(assignCtx.id());
Sexp body = sexp(assignCtx.body());
model.addValue(var, body);
} else {
FnAppContext fnApp = assignCtx.fnApp();
String name = getId(fnApp.id());
FunctionTable table = model.getFunctionTable(name);
SexpEvaluator eval = new SexpEvaluator(model);
List<Value> inputs = new ArrayList<>();
for (BodyContext arg : fnApp.body()) {
inputs.add(eval.eval(sexp(arg)));
}
Value output = eval.eval(sexp(assignCtx.body()));
table.addRow(inputs, output);
}
}
private static String getId(IdContext id) {
return Quoting.unquote(id.getText());
}
private static Sexp sexp(BodyContext ctx) {
if (ctx instanceof SymbolBodyContext) {
SymbolBodyContext sbc = (SymbolBodyContext) ctx;
return new Symbol(sbc.symbol().getText());
} else if (ctx instanceof ConsBodyContext) {
ConsBodyContext cbc = (ConsBodyContext) ctx;
List<Sexp> args = new ArrayList<>();
for (BodyContext sub : cbc.body()) {
args.add(sexp(sub));
}
return new Cons(cbc.fn().getText(), args);
} else {
throw new IllegalArgumentException();
}
}
}
| 2,383
| 31.216216
| 110
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/smtinterpol/SmtInterpolSolver.java
|
package jkind.solvers.smtinterpol;
import java.util.ArrayList;
import java.util.List;
import de.uni_freiburg.informatik.ultimate.logic.Annotation;
import de.uni_freiburg.informatik.ultimate.logic.Logics;
import de.uni_freiburg.informatik.ultimate.logic.QuotedObject;
import de.uni_freiburg.informatik.ultimate.logic.Script;
import de.uni_freiburg.informatik.ultimate.logic.Sort;
import de.uni_freiburg.informatik.ultimate.logic.Term;
import de.uni_freiburg.informatik.ultimate.logic.TermVariable;
import jkind.JKindException;
import jkind.lustre.Function;
import jkind.lustre.Type;
import jkind.lustre.VarDecl;
import jkind.sexp.Cons;
import jkind.sexp.Sexp;
import jkind.sexp.Symbol;
import jkind.solvers.Model;
import jkind.solvers.Result;
import jkind.solvers.SatResult;
import jkind.solvers.Solver;
import jkind.solvers.UnknownResult;
import jkind.solvers.UnsatResult;
import jkind.solvers.smtlib2.SmtLib2Solver;
import jkind.translation.Relation;
public class SmtInterpolSolver extends Solver {
private final Script script;
public SmtInterpolSolver(String scratchBase) {
this.script = SmtInterpolUtil.getScript(scratchBase);
}
@Override
public void initialize() {
script.setOption(":produce-unsat-cores", true);
script.setLogic(Logics.QF_UFLIRA);
script.setOption(":verbosity", 2);
}
@Override
public void assertSexp(Sexp sexp) {
script.assertTerm(convert(sexp));
}
@Override
public void define(VarDecl decl) {
varTypes.put(decl.id, decl.type);
script.declareFun(decl.id, new Sort[0], getSort(decl.type));
}
@Override
public void declare(Function function) {
functions.add(function);
SmtInterpolUtil.declareFunction(script, function);
}
@Override
public void define(Relation relation) {
TermVariable[] params = createTermVariables(relation.getInputs());
Term definition = convert(params, relation.getBody());
script.defineFun(relation.getName(), params, script.sort("Bool"), definition);
}
private TermVariable[] createTermVariables(List<VarDecl> inputs) {
return inputs.stream().map(this::createTermVariable).toArray(i -> new TermVariable[i]);
}
private TermVariable createTermVariable(VarDecl decl) {
return script.variable(decl.id, getSort(decl.type));
}
@Override
public Result query(Sexp sexp) {
Model model;
push();
assertSexp(new Cons("not", sexp));
switch (script.checkSat()) {
case SAT:
model = extractModel(script.getModel());
pop();
return new SatResult(model);
case UNSAT:
pop();
return new UnsatResult();
case UNKNOWN:
model = extractModel(script.getModel());
pop();
return new UnknownResult(model);
}
throw new JKindException("Unhandled result from solver");
}
@Override
protected Result quickCheckSat(List<Symbol> activationLiterals) {
push();
for (Symbol actLit : activationLiterals) {
String name = "_" + actLit.str;
script.assertTerm(script.annotate(convert(actLit), new Annotation(":named", name)));
}
switch (script.checkSat()) {
case SAT:
pop();
return new SatResult();
case UNSAT:
List<Symbol> unsatCore = new ArrayList<>();
for (Term t : script.getUnsatCore()) {
unsatCore.add(new Symbol(t.toString().substring(1)));
}
pop();
return new UnsatResult(unsatCore);
case UNKNOWN:
pop();
return new UnknownResult();
}
throw new JKindException("Unhandled result from solver");
}
private Model extractModel(de.uni_freiburg.informatik.ultimate.logic.Model model) {
return SmtLib2Solver.parseSmtLib2Model(model.toString(), varTypes, functions);
}
@Override
public void push() {
script.push(1);
}
@Override
public void pop() {
script.pop(1);
}
@Override
public void comment(String str) {
script.echo(new QuotedObject(str));
}
@Override
public void stop() {
}
private Sort getSort(Type type) {
return SmtInterpolUtil.getSort(script, type);
}
private Term convert(TermVariable[] params, Sexp sexp) {
return SmtInterpolUtil.convert(script, params, sexp);
}
private Term convert(Sexp sexp) {
return SmtInterpolUtil.convert(script, sexp);
}
}
| 4,073
| 23.542169
| 89
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/smtinterpol/Subst.java
|
package jkind.solvers.smtinterpol;
import de.uni_freiburg.informatik.ultimate.logic.ApplicationTerm;
import de.uni_freiburg.informatik.ultimate.logic.ConstantTerm;
import de.uni_freiburg.informatik.ultimate.logic.Script;
import de.uni_freiburg.informatik.ultimate.logic.Term;
public class Subst {
public static Term apply(Script script, Term term, Term[] variables, Term[] arguments) {
int i = indexOf(variables, term);
if (i >= 0) {
return arguments[i];
}
if (term instanceof ApplicationTerm) {
return apply(script, (ApplicationTerm) term, variables, arguments);
} else if (term instanceof ConstantTerm) {
return term;
}
throw new IllegalArgumentException("Unhandled: " + term.getClass().getSimpleName());
}
private static int indexOf(Term[] terms, Term term) {
for (int i = 0; i < terms.length; i++) {
if (terms[i] == term) {
return i;
}
}
return -1;
}
private static Term apply(Script script, ApplicationTerm at, Term[] variables, Term[] arguments) {
Term[] params = at.getParameters();
Term[] terms = new Term[params.length];
for (int i = 0; i < params.length; i++) {
terms[i] = apply(script, params[i], variables, arguments);
}
return script.term(at.getFunction().getName(), terms);
}
}
| 1,256
| 28.928571
| 99
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/smtinterpol/Term2Expr.java
|
package jkind.solvers.smtinterpol;
import static java.util.stream.Collectors.toList;
import static jkind.lustre.LustreUtil.castInt;
import static jkind.lustre.LustreUtil.castReal;
import static jkind.lustre.LustreUtil.divide;
import static jkind.lustre.LustreUtil.negative;
import static jkind.lustre.LustreUtil.not;
import static jkind.lustre.LustreUtil.notEqual;
import static jkind.lustre.LustreUtil.real;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.List;
import de.uni_freiburg.informatik.ultimate.logic.ApplicationTerm;
import de.uni_freiburg.informatik.ultimate.logic.ConstantTerm;
import de.uni_freiburg.informatik.ultimate.logic.Rational;
import de.uni_freiburg.informatik.ultimate.logic.Term;
import jkind.engines.pdr.Lustre2Term;
import jkind.lustre.BinaryExpr;
import jkind.lustre.BinaryOp;
import jkind.lustre.BoolExpr;
import jkind.lustre.Expr;
import jkind.lustre.FunctionCallExpr;
import jkind.lustre.IdExpr;
import jkind.lustre.IfThenElseExpr;
import jkind.lustre.IntExpr;
import jkind.lustre.RealExpr;
import jkind.util.SexpUtil;
public class Term2Expr {
public static Expr disjunction(List<Term> disjuncts) {
if (disjuncts.isEmpty()) {
return new BoolExpr(false);
}
return leftAssociate("or", disjuncts.toArray(new Term[disjuncts.size()]));
}
public static Expr expr(Term term) {
if (term instanceof ConstantTerm) {
return expr((ConstantTerm) term);
} else if (term instanceof ApplicationTerm) {
return expr((ApplicationTerm) term);
} else {
throw new IllegalArgumentException("Unhandled term type: " + term.getClass().getSimpleName());
}
}
private static Expr expr(ConstantTerm ct) {
if (ct.getValue() instanceof BigInteger) {
BigInteger bi = (BigInteger) ct.getValue();
return new IntExpr(bi);
} else if (ct.getValue() instanceof BigDecimal) {
BigDecimal bd = (BigDecimal) ct.getValue();
return new RealExpr(bd);
} else if (ct.getValue() instanceof Rational) {
Rational r = (Rational) ct.getValue();
return divide(real(r.numerator()), real(r.denominator()));
} else {
throw new IllegalArgumentException("Unhandled constant term type: " + ct.getClass().getSimpleName());
}
}
private static Expr expr(ApplicationTerm at) {
String name = at.getFunction().getName();
Term[] params = at.getParameters();
if (SexpUtil.isEncodedFunction(name)) {
List<Expr> exprParams = Arrays.stream(params).map(p -> expr(p)).collect(toList());
return new FunctionCallExpr(SexpUtil.decodeFunction(name), exprParams);
}
if (params.length == 0) {
switch (name) {
case "true":
return new BoolExpr(true);
case "false":
return new BoolExpr(false);
case Lustre2Term.INIT:
// Term2Expr should only be used on terms outside the INIT
// state, so we can INIT is always false.
return new BoolExpr(false);
default:
return new IdExpr(Lustre2Term.decode(name));
}
}
if (params.length == 1) {
switch (name) {
case "-":
return negative(expr(params[0]));
case "not":
return not(expr(params[0]));
case "to_real":
return castReal(expr(params[0]));
case "to_int":
return castInt(expr(params[0]));
default:
throw new IllegalArgumentException("Unknown unary operator: " + name);
}
}
if (params.length == 2) {
switch (name) {
case "distinct":
return notEqual(expr(params[0]), expr(params[1]));
default:
BinaryOp op = BinaryOp.fromString(name);
return new BinaryExpr(expr(params[0]), op, expr(params[1]));
}
}
if (params.length == 3 && name.equals("ite")) {
return new IfThenElseExpr(expr(params[0]), expr(params[1]), expr(params[2]));
}
if (leftAssociative(name)) {
return leftAssociate(name, params);
} else if (rightAssociative(name)) {
return rightAssociate(name, params);
}
throw new IllegalArgumentException("Unknown term: " + at);
}
private static boolean leftAssociative(String name) {
switch (name) {
case "and":
case "or":
case "xor":
case "+":
case "-":
case "*":
case "/":
case "div":
return true;
default:
return false;
}
}
private static Expr leftAssociate(String name, Term[] params) {
BinaryOp op = BinaryOp.fromString(name);
Expr expr = expr(params[0]);
for (int i = 1; i < params.length; i++) {
expr = new BinaryExpr(expr, op, expr(params[i]));
}
return expr;
}
private static boolean rightAssociative(String name) {
return name.equals("=>");
}
private static Expr rightAssociate(String name, Term[] params) {
BinaryOp op = BinaryOp.fromString(name);
Expr expr = expr(params[params.length - 1]);
for (int i = params.length - 2; i >= 0; i--) {
expr = new BinaryExpr(expr(params[i]), op, expr);
}
return expr;
}
}
| 4,765
| 27.035294
| 104
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/smtinterpol/ScriptUser.java
|
package jkind.solvers.smtinterpol;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.List;
import de.uni_freiburg.informatik.ultimate.logic.Script;
import de.uni_freiburg.informatik.ultimate.logic.Term;
import de.uni_freiburg.informatik.ultimate.logic.Util;
public abstract class ScriptUser {
protected final Script script;
public ScriptUser(Script script) {
this.script = script;
}
protected Term term(String funcname, Term... params) {
return script.term(funcname, params);
}
protected Term not(Term term) {
return Util.not(script, term);
}
protected Term and(List<Term> conjuncts) {
return Util.and(script, conjuncts.toArray(new Term[conjuncts.size()]));
}
protected Term and(Term... conjuncts) {
return Util.and(script, conjuncts);
}
protected Term or(Term... disjuncts) {
return Util.or(script, disjuncts);
}
protected Term ite(Term cond, Term thenPart, Term elsePart) {
return Util.ite(script, cond, thenPart, elsePart);
}
protected Term numeral(BigInteger value) {
return script.numeral(value);
}
protected Term numeral(long value) {
return script.numeral(BigInteger.valueOf(value));
}
protected Term decimal(BigDecimal value) {
return script.decimal(value);
}
}
| 1,249
| 22.148148
| 73
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/smtinterpol/SmtInterpolUtil.java
|
package jkind.solvers.smtinterpol;
import java.io.IOException;
import java.util.List;
import de.uni_freiburg.informatik.ultimate.logic.LoggingScript;
import de.uni_freiburg.informatik.ultimate.logic.Script;
import de.uni_freiburg.informatik.ultimate.logic.Sort;
import de.uni_freiburg.informatik.ultimate.logic.Term;
import de.uni_freiburg.informatik.ultimate.logic.TermVariable;
import de.uni_freiburg.informatik.ultimate.smtinterpol.smtlib2.SMTInterpol;
import jkind.JKindException;
import jkind.lustre.EnumType;
import jkind.lustre.Function;
import jkind.lustre.NamedType;
import jkind.lustre.SubrangeIntType;
import jkind.lustre.Type;
import jkind.lustre.VarDecl;
import jkind.sexp.Cons;
import jkind.sexp.Sexp;
import jkind.sexp.Symbol;
import jkind.util.SexpUtil;
public class SmtInterpolUtil {
public static Script getScript(String scratchBase) {
Script baseScript = new SMTInterpol();
if (scratchBase == null) {
return baseScript;
}
String filename = scratchBase + ".smt2";
try {
return new LoggingScript(baseScript, filename, true);
} catch (IOException e) {
throw new JKindException("Unable to open scratch file: " + filename, e);
}
}
public static Sort getSort(Script script, Type type) {
if (type instanceof NamedType) {
NamedType namedType = (NamedType) type;
switch (namedType.name) {
case "bool":
return script.sort("Bool");
case "int":
return script.sort("Int");
case "real":
return script.sort("Real");
}
} else if (type instanceof SubrangeIntType || type instanceof EnumType) {
return script.sort("Int");
}
throw new JKindException("Unhandled type " + type);
}
public static Term convert(Script script, Sexp sexp) {
return convert(script, new TermVariable[0], sexp);
}
public static Term convert(Script script, TermVariable[] params, Sexp sexp) {
if (sexp instanceof Cons) {
Cons cons = (Cons) sexp;
return convert(script, params, cons);
} else if (sexp instanceof Symbol) {
Symbol symbol = (Symbol) sexp;
return convert(script, params, symbol);
} else {
throw new JKindException("Unknown sexp: " + sexp);
}
}
private static Term convert(Script script, TermVariable[] params, Cons cons) {
if (!(cons.head instanceof Symbol)) {
throw new JKindException("Cannot convert complex sexp to term: " + cons);
}
String head = ((Symbol) cons.head).str;
Term[] args = new Term[cons.args.size()];
for (int i = 0; i < cons.args.size(); i++) {
args[i] = convert(script, params, cons.args.get(i));
}
return script.term(head, args);
}
private static Term convert(Script script, TermVariable[] params, Symbol symbol) {
String text = symbol.str;
if (text.matches("^[0-9]+$")) {
return script.numeral(text);
}
for (int i = 0; i < params.length; i++) {
if (params[i].getName().equals(text)) {
return params[i];
}
}
return script.term(text);
}
public static Sort[] getSorts(Script script, List<VarDecl> vars) {
Sort[] sorts = new Sort[vars.size()];
for (int i = 0; i < vars.size(); i++) {
sorts[i] = getSort(script, vars.get(i).type);
}
return sorts;
}
public static void declareFunction(Script script, Function function) {
String encodedName = SexpUtil.encodeFunction(function.id);
Sort[] inputs = getSorts(script, function.inputs);
Sort output = getSort(script, function.outputs.get(0).type);
script.declareFun(encodedName, inputs, output);
}
}
| 3,429
| 28.316239
| 83
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/smtinterpol/NameAppender.java
|
package jkind.solvers.smtinterpol;
import de.uni_freiburg.informatik.ultimate.logic.ApplicationTerm;
import de.uni_freiburg.informatik.ultimate.logic.Script;
import de.uni_freiburg.informatik.ultimate.logic.Term;
public class NameAppender {
private final Script script;
private final String suffix;
public NameAppender(Script script, String suffix) {
this.script = script;
this.suffix = suffix;
}
public Term append(Term t) {
if (t instanceof ApplicationTerm) {
return append((ApplicationTerm) t);
}
throw new IllegalArgumentException("Unknown term: " + t.getClass().getSimpleName());
}
private Term append(ApplicationTerm at) {
String name = at.getFunction().getName();
if (at.getParameters().length == 0) {
if (name.equals("true") || name.equals("false")) {
return at;
} else {
return script.term(name + suffix);
}
} else {
return script.term(name, append(at.getParameters()));
}
}
private Term[] append(Term[] terms) {
Term[] result = new Term[terms.length];
for (int i = 0; i < terms.length; i++) {
result[i] = append(terms[i]);
}
return result;
}
}
| 1,123
| 23.977778
| 86
|
java
|
jkind
|
jkind-master/jkind/src/jkind/solvers/smtinterpol/TerminationRequestImpl.java
|
package jkind.solvers.smtinterpol;
import de.uni_freiburg.informatik.ultimate.smtinterpol.smtlib2.TerminationRequest;
public class TerminationRequestImpl implements TerminationRequest {
private boolean requestTermination = false;
public void requestTermination() {
this.requestTermination = true;
}
@Override
public boolean isTerminationRequested() {
// TODO Auto-generated method stub
return this.requestTermination;
}
}
| 440
| 21.05
| 82
|
java
|
jkind
|
jkind-master/jkind/src/jkind/analysis/YicesArithOnlyCheck.java
|
package jkind.analysis;
import jkind.lustre.BinaryExpr;
import jkind.lustre.BinaryOp;
import jkind.lustre.CastExpr;
import jkind.lustre.FunctionCallExpr;
import jkind.lustre.Node;
import jkind.lustre.visitors.AstIterVisitor;
/**
* The arith-only feature for yices yields generally improved performance, but
* it is not available if we use casting, modulus, or integer division.
*/
public class YicesArithOnlyCheck extends AstIterVisitor {
public static boolean check(Node node) {
YicesArithOnlyCheck visitor = new YicesArithOnlyCheck();
node.accept(visitor);
return visitor.arithOnly;
}
private boolean arithOnly = true;
@Override
public Void visit(BinaryExpr e) {
if (e.op == BinaryOp.MODULUS || e.op == BinaryOp.INT_DIVIDE) {
arithOnly = false;
} else {
super.visit(e);
}
return null;
}
@Override
public Void visit(CastExpr e) {
arithOnly = false;
return null;
}
@Override
public Void visit(FunctionCallExpr e) {
arithOnly = false;
return null;
}
}
| 1,000
| 21.244444
| 78
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.