├── .gitignore ├── COLLABORATORS ├── LICENSE ├── LICENSE-doop-orig ├── README.md ├── bin ├── analyze-droidbench.py ├── android-check.sh ├── bench-native-scanner.sh ├── db-analyser.py ├── diff-analyses.sh ├── diff-souffle-lb.sh ├── doop_runner.py ├── facts-to-json.py ├── gen-decls-doc.py ├── lib-local-deploy.gradle ├── log-analyzer.py ├── mkjar ├── oracular-1type+h.py ├── oracular.py ├── parse_beans.rb ├── run-dex-with-ssa.sh ├── run-with-redirection.sh ├── souffleScript ├── taint_network.py └── zipper.py ├── build.gradle ├── docs ├── datalog-101-legacy-examples │ ├── ancestors-facts.logic │ ├── ancestors.logic │ ├── graph.logic │ ├── path-facts.logic │ ├── path.logic │ ├── person-facts.logic │ └── person.logic ├── datalog-101-legacy.md ├── docker │ ├── Dockerfile │ ├── README.md │ ├── docker-build-and-push.sh │ └── legacy │ │ ├── Dockerfile │ │ └── README.md ├── documentation.md ├── doop-101-examples │ ├── .gitignore │ ├── Example.java │ ├── Makefile │ ├── query2.logic │ └── query3.logic ├── doop-101.md ├── doop-as-lib │ ├── .gitignore │ ├── README.md │ ├── build.gradle │ ├── gradle │ │ └── wrapper │ │ │ ├── gradle-wrapper.jar │ │ │ └── gradle-wrapper.properties │ ├── gradlew │ ├── gradlew.bat │ ├── settings.gradle │ └── src │ │ └── main │ │ └── java │ │ └── DoopRunner.java ├── ptaint.md ├── pythia.md ├── rules.html └── vscode-sarif-example.png ├── doop ├── doop.bat ├── doopOffline ├── generators ├── code-processor │ ├── README.md │ ├── build.gradle │ └── src │ │ └── main │ │ ├── antlr │ │ └── org │ │ │ └── clyze │ │ │ └── doop │ │ │ └── jimple │ │ │ └── Jimple.g4 │ │ └── groovy │ │ └── org │ │ └── clyze │ │ └── doop │ │ ├── jimple │ │ ├── JimpleListenerImpl.groovy │ │ ├── JimpleProcessor.groovy │ │ └── Main.groovy │ │ └── sarif │ │ ├── RMetadata.groovy │ │ └── SARIFGenerator.groovy ├── dex-fact-generator │ ├── build.gradle │ └── src │ │ └── main │ │ └── java │ │ └── org │ │ └── clyze │ │ └── doop │ │ └── dex │ │ ├── DexAndroidSupport.java │ │ ├── DexClassFactWriter.java │ │ ├── DexDriver.java │ │ ├── DexFactWriter.java │ │ ├── DexFieldInfo.java │ │ ├── DexInvoker.java │ │ ├── DexMethodFactWriter.java │ │ ├── DexParameters.java │ │ ├── DexRepresentation.java │ │ ├── DexUtils.java │ │ ├── FillArrayInfoEntry.java │ │ ├── FirstInstructionEntry.java │ │ ├── Handler.java │ │ ├── InferType.java │ │ ├── InitialValue.java │ │ ├── MethodFacts.java │ │ ├── MethodSig.java │ │ ├── MoveExceptionInfo.java │ │ ├── NewArrayInfo.java │ │ ├── ObjectReturnInfo.java │ │ ├── PatternManager.java │ │ ├── RawGoto.java │ │ └── ZeroedRegister.java ├── fact-generator-common │ ├── build.gradle │ └── src │ │ └── main │ │ └── java │ │ └── org │ │ └── clyze │ │ └── doop │ │ ├── common │ │ ├── ArtifactEntry.java │ │ ├── ArtifactScanner.java │ │ ├── BasicJavaSupport.java │ │ ├── BytecodeUtil.java │ │ ├── CHA.java │ │ ├── Database.java │ │ ├── DatabaseConnector.java │ │ ├── DoopErrorCodeException.java │ │ ├── Driver.java │ │ ├── FactEncoders.java │ │ ├── FieldInfo.java │ │ ├── FieldOp.java │ │ ├── FrontEndLogger.java │ │ ├── GenericFieldInfo.java │ │ ├── GenericSignaturesRetriever.java │ │ ├── InstrInfo.java │ │ ├── JavaFactWriter.java │ │ ├── JavaRepresentation.java │ │ ├── Parameters.java │ │ ├── Phantoms.java │ │ ├── PredicateFile.java │ │ ├── PropertyProvider.java │ │ ├── SessionCounter.java │ │ ├── XMLFactGenerator.java │ │ ├── android │ │ │ ├── AndroidSupport.java │ │ │ ├── AppResources.java │ │ │ ├── AppResourcesXML.java │ │ │ ├── LayoutControl.java │ │ │ └── RLinker.java │ │ └── scanner │ │ │ └── antlr │ │ │ ├── GenericTypeBaseVisitor.java │ │ │ ├── GenericTypeLexer.java │ │ │ ├── GenericTypeParser.java │ │ │ ├── GenericTypeVisitor.java │ │ │ └── PrintVisitor.java │ │ ├── soot │ │ └── DoopConventions.java │ │ └── util │ │ ├── PackageUtil.java │ │ ├── PackageUtils.java │ │ ├── Regex.java │ │ ├── Resource.java │ │ └── filter │ │ ├── ClassFilter.java │ │ └── GlobClassFilter.java ├── soot-fact-generator │ ├── build.gradle │ └── src │ │ ├── main │ │ └── java │ │ │ └── org │ │ │ └── clyze │ │ │ └── doop │ │ │ └── soot │ │ │ ├── BasicJavaSupport_Soot.java │ │ │ ├── ClassAdder.java │ │ │ ├── ClassConstantInfo.java │ │ │ ├── ClassHeapFinder.java │ │ │ ├── DoopAddons.java │ │ │ ├── DoopRenamer.java │ │ │ ├── FactGenerator.java │ │ │ ├── FactWriter.java │ │ │ ├── IrrelevantStmtSwitch.java │ │ │ ├── JimpleGenerator.java │ │ │ ├── Main.java │ │ │ ├── Representation.java │ │ │ ├── SootDriver.java │ │ │ ├── SootParameters.java │ │ │ └── android │ │ │ └── AndroidSupport_Soot.java │ │ └── test │ │ └── groovy │ │ └── org │ │ └── clyze │ │ └── doop │ │ └── soot │ │ ├── DoopConventionsTest.groovy │ │ └── SootParametersTest.groovy └── wala-fact-generator │ ├── build.gradle │ ├── local-libs │ ├── com.ibm.wala.cast-1.5.1-SNAPSHOT.jar │ ├── com.ibm.wala.cast.java-1.5.1-SNAPSHOT.jar │ ├── com.ibm.wala.cast.python-0.0.1-SNAPSHOT.jar │ ├── com.ibm.wala.core-1.5.1-SNAPSHOT.jar │ ├── com.ibm.wala.dalvik-1.5.1-SNAPSHOT.jar │ ├── com.ibm.wala.shrike-1.5.1-SNAPSHOT.jar │ └── com.ibm.wala.util-1.5.1-SNAPSHOT.jar │ └── src │ └── main │ ├── java │ └── org │ │ └── clyze │ │ └── doop │ │ ├── python │ │ ├── PythonFactGenerator.java │ │ ├── PythonFactWriter.java │ │ ├── PythonIREngine.java │ │ ├── PythonInvoker.java │ │ ├── PythonParameters.java │ │ ├── PythonRepresentation.java │ │ └── utils │ │ │ ├── PythonDatabase.java │ │ │ ├── PythonIRPrinter.java │ │ │ ├── PythonPredicateFile.java │ │ │ └── PythonUtils.java │ │ └── wala │ │ ├── Local.java │ │ ├── Main.java │ │ ├── Session.java │ │ ├── WalaAndroidXMLParser.java │ │ ├── WalaDriver.java │ │ ├── WalaExceptionHelper.java │ │ ├── WalaFactGenerator.java │ │ ├── WalaFactWriter.java │ │ ├── WalaIRPrinter.java │ │ ├── WalaInvoker.java │ │ ├── WalaRepresentation.java │ │ ├── WalaScopeReader.java │ │ └── WalaUtils.java │ └── resources │ ├── WALAprimordial.jar.model │ └── WALAprimordial.txt ├── gradle.properties ├── gradle └── wrapper │ ├── gradle-wrapper.jar │ └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat ├── lb-logic ├── addons │ ├── cfg-analysis │ │ ├── analysis.logic │ │ ├── declarations.logic │ │ └── tests.logic │ ├── dacapo │ │ └── rules.logic │ ├── information-flow │ │ ├── alfresco-sources-and-sinks.logic │ │ ├── android-sources-and-sinks.logic │ │ ├── android-taint-wrappers.logic │ │ ├── android.logic │ │ ├── beans-sources-and-sinks.logic │ │ ├── common-transfer-methods.logic │ │ ├── declarations.logic │ │ ├── delta.logic │ │ ├── macros.logic │ │ ├── minimal-sources-and-sinks.logic │ │ ├── query.logic │ │ ├── rules.logic │ │ ├── spring-sources-and-sinks.logic │ │ └── webapps-sources-and-sinks.logic │ ├── open-programs │ │ ├── entry-points.logic │ │ ├── rules-concrete-types.logic │ │ └── rules-servlets-only.logic │ ├── queries │ │ └── classifyVPT.logic │ ├── sanity.logic │ ├── server-logic │ │ └── queries.logic │ ├── statistics │ │ ├── macros.logic │ │ ├── statistics-simple.logic │ │ └── statistics.logic │ ├── tamiflex │ │ ├── declarations.logic │ │ ├── delta.logic │ │ ├── fact-declarations.logic │ │ ├── import.logic │ │ ├── post-import.logic │ │ └── rules.logic │ └── transform │ │ ├── declarations.logic │ │ ├── delta.logic │ │ └── rules.logic ├── analyses │ ├── 1-call-site-sensitive+heap │ │ ├── analysis.logic │ │ ├── delta.logic │ │ └── macros.logic │ ├── 1-call-site-sensitive │ │ ├── analysis.logic │ │ ├── delta.logic │ │ └── macros.logic │ ├── 1-object-sensitive+heap │ │ ├── analysis.logic │ │ └── macros.logic │ ├── 1-object-sensitive │ │ ├── analysis.logic │ │ └── macros.logic │ ├── 1-type-sensitive+heap │ │ ├── analysis.logic │ │ ├── delta.logic │ │ └── macros.logic │ ├── 1-type-sensitive │ │ ├── analysis.logic │ │ ├── delta.logic │ │ └── macros.logic │ ├── 2-call-site-sensitive+2-heap │ │ ├── analysis.logic │ │ ├── delta.logic │ │ └── macros.logic │ ├── 2-call-site-sensitive+heap │ │ ├── analysis.logic │ │ ├── delta.logic │ │ └── macros.logic │ ├── 2-object-sensitive+2-heap │ │ ├── analysis.logic │ │ └── macros.logic │ ├── 2-object-sensitive+heap-plus │ │ ├── analysis.logic │ │ └── macros.logic │ ├── 2-object-sensitive+heap │ │ ├── analysis.logic │ │ └── macros.logic │ ├── 2-type-object-sensitive+2-heap │ │ ├── analysis.logic │ │ └── macros.logic │ ├── 2-type-object-sensitive+heap │ │ ├── analysis.logic │ │ └── macros.logic │ ├── 2-type-sensitive+heap │ │ ├── analysis.logic │ │ ├── delta.logic │ │ └── macros.logic │ ├── 3-object-sensitive+3-heap │ │ ├── analysis.logic │ │ └── macros.logic │ ├── 3-type-sensitive+2-heap │ │ ├── analysis.logic │ │ ├── delta.logic │ │ └── macros.logic │ ├── 3-type-sensitive+3-heap │ │ ├── analysis.logic │ │ ├── delta.logic │ │ └── macros.logic │ ├── adaptive-insens-2objH │ │ ├── analysis.logic │ │ └── macros.logic │ ├── adaptive2-insens-2objH │ │ ├── analysis.logic │ │ ├── analysis.old │ │ ├── inoutscc.logic │ │ └── macros.logic │ ├── context-insensitive-plus │ │ ├── analysis.logic │ │ └── macros.logic │ ├── context-insensitive-plusplus │ │ ├── analysis.logic │ │ └── macros.logic │ ├── context-insensitive │ │ ├── analysis.logic │ │ └── macros.logic │ ├── dependency-analysis │ │ ├── analysis.logic │ │ ├── declarations.logic │ │ ├── delta.logic │ │ └── macros.logic │ ├── escape │ │ ├── declarations.logic │ │ ├── queries.logic │ │ ├── rules.logic │ │ ├── run.lb │ │ └── wrap.sh │ ├── micro │ │ ├── analysis.logic │ │ ├── analysis.properties │ │ ├── declarations.logic │ │ ├── macros.logic │ │ ├── statistics.logic │ │ └── statistics.part.lb │ ├── must-point-to │ │ ├── analysis-simple.logic │ │ ├── analysis.logic │ │ ├── may-pre-analysis.logic │ │ ├── points-alias-simple.logic │ │ └── tests.logic │ ├── naive │ │ ├── analysis.logic │ │ ├── analysis.properties │ │ ├── declarations.logic │ │ ├── macros.logic │ │ ├── statistics.logic │ │ └── statistics.part.lb │ ├── paddle-2-object-sensitive+heap │ │ ├── analysis.logic │ │ └── macros.logic │ ├── paddle-2-object-sensitive │ │ ├── analysis.logic │ │ └── macros.logic │ ├── partial-insens-s2objH │ │ ├── analysis.logic │ │ └── macros.logic │ ├── partitioned-2-object-sensitive+heap │ │ ├── analysis.logic │ │ └── macros.logic │ ├── refA-2-call-site-sensitive+heap │ │ ├── analysis.logic │ │ ├── delta.logic │ │ ├── macros.logic │ │ └── refinement-delta.logic │ ├── refA-2-object-sensitive+heap │ │ ├── analysis.logic │ │ ├── macros.logic │ │ └── refinement-delta.logic │ ├── refA-2-type-sensitive+heap │ │ ├── analysis.logic │ │ ├── delta.logic │ │ ├── macros.logic │ │ └── refinement-delta.logic │ ├── refB-2-call-site-sensitive+heap │ │ ├── analysis.logic │ │ ├── delta.logic │ │ ├── macros.logic │ │ └── refinement-delta.logic │ ├── refB-2-object-sensitive+heap │ │ ├── analysis.logic │ │ ├── macros.logic │ │ └── refinement-delta.logic │ ├── refB-2-type-sensitive+heap │ │ ├── analysis.logic │ │ ├── delta.logic │ │ ├── macros.logic │ │ └── refinement-delta.logic │ ├── scc-2-object-sensitive+heap │ │ ├── analysis.logic │ │ └── macros.logic │ ├── selective-2-object-sensitive+heap │ │ ├── analysis.logic │ │ └── macros.logic │ ├── selective-2-type-sensitive+heap │ │ ├── analysis.logic │ │ ├── delta.logic │ │ └── macros.logic │ ├── selective_A-1-object-sensitive │ │ ├── analysis.logic │ │ └── macros.logic │ ├── selective_B-1-object-sensitive │ │ ├── analysis.logic │ │ └── macros.logic │ ├── sound-may-point-to │ │ ├── analysis.logic │ │ ├── intraprocedural-must.logic │ │ ├── must-alias.logic │ │ ├── must-point-to.logic │ │ ├── sound-may.logic │ │ ├── statistics.logic │ │ └── statistics.part.lb │ ├── special-2-object-sensitive+heap │ │ └── analysis.logic │ ├── special-2-type-sensitive+heap │ │ └── analysis.dl │ ├── stutter-2-object-sensitive+heap │ │ ├── analysis.logic │ │ └── macros.logic │ ├── uniform-1-object-sensitive │ │ ├── analysis.logic │ │ ├── delta.logic │ │ └── macros.logic │ ├── uniform-2-object-sensitive+heap │ │ ├── analysis.logic │ │ ├── delta.logic │ │ └── macros.logic │ └── uniform-2-type-sensitive+heap │ │ ├── analysis.logic │ │ ├── delta.logic │ │ └── macros.logic ├── basic │ ├── basic-declarations.logic │ ├── basic.logic │ ├── finalization-declarations.logic │ ├── finalization.logic │ ├── method-resolution-declarations.logic │ ├── method-resolution.logic │ ├── subclass-declarations.logic │ ├── subclass.logic │ ├── superinterface-declarations.logic │ ├── superinterface.logic │ ├── type-hierarchy-declarations.logic │ └── type-hierarchy.logic ├── commonMacros.logic ├── dead │ ├── addons │ │ ├── auxiliary-heap-allocations │ │ │ ├── declarations.logic │ │ │ └── delta.logic │ │ ├── fu-exception-flow │ │ │ ├── declarations.logic │ │ │ ├── delta.logic │ │ │ └── rules.logic │ │ ├── graph │ │ │ ├── basic-declarations.logic │ │ │ ├── basic.logic │ │ │ └── scc │ │ │ │ ├── SCC-approx.logic │ │ │ │ └── spanning.logic │ │ ├── rules-reference-types.logic │ │ └── type-analysis.logic │ ├── analyses │ │ ├── core │ │ │ └── exceptions │ │ │ │ ├── experimental-declarations.logic │ │ │ │ ├── experimental.logic │ │ │ │ ├── imprecise-declarations.logic │ │ │ │ └── imprecise.logic │ │ ├── experimental │ │ │ ├── 1-call+1-object-sensitive+2-heap │ │ │ │ ├── analysis.logic │ │ │ │ ├── declarations.logic │ │ │ │ ├── delta.logic │ │ │ │ └── macros.logic │ │ │ ├── 2-1-object-sensitive+heap │ │ │ │ ├── README.txt │ │ │ │ ├── analysis.logic │ │ │ │ ├── declarations.logic │ │ │ │ ├── delta.logic │ │ │ │ └── macros.logic │ │ │ ├── 3-1-type-2-object-sensitive+3-heap │ │ │ │ ├── analysis.logic │ │ │ │ ├── declarations.logic │ │ │ │ ├── delta.logic │ │ │ │ └── macros.logic │ │ │ ├── 3-2-type-1-object-sensitive+2-heap │ │ │ │ ├── analysis.logic │ │ │ │ ├── declarations.logic │ │ │ │ ├── delta.logic │ │ │ │ └── macros.logic │ │ │ ├── 3-2-type-1-object-sensitive+3-heap │ │ │ │ ├── analysis.logic │ │ │ │ ├── declarations.logic │ │ │ │ ├── delta.logic │ │ │ │ └── macros.logic │ │ │ ├── baseline_1-obj+1-call+2H │ │ │ │ ├── analysis.logic │ │ │ │ ├── declarations.logic │ │ │ │ ├── delta.logic │ │ │ │ └── macros.logic │ │ │ ├── baseline_1-obj+1-call+H-B │ │ │ │ ├── analysis.logic │ │ │ │ ├── declarations.logic │ │ │ │ ├── delta.logic │ │ │ │ └── macros.logic │ │ │ ├── baseline_1-obj+1-call+H │ │ │ │ ├── analysis.logic │ │ │ │ ├── declarations.logic │ │ │ │ ├── delta.logic │ │ │ │ └── macros.logic │ │ │ ├── hybrid-1-object-sensitive+heap-B │ │ │ │ ├── analysis.logic │ │ │ │ ├── declarations.logic │ │ │ │ ├── delta.logic │ │ │ │ └── macros.logic │ │ │ ├── hybrid-1-object-sensitive+heap │ │ │ │ ├── analysis.logic │ │ │ │ ├── declarations.logic │ │ │ │ ├── delta.logic │ │ │ │ └── macros.logic │ │ │ ├── hybrid-1-type-sensitive+heap │ │ │ │ ├── analysis.logic │ │ │ │ ├── declarations.logic │ │ │ │ ├── delta.logic │ │ │ │ └── macros.logic │ │ │ ├── hybrid-2-full-object-sensitive+2-heap │ │ │ │ ├── analysis.logic │ │ │ │ ├── declarations.logic │ │ │ │ ├── delta.logic │ │ │ │ └── macros.logic │ │ │ ├── hybrid-2-full-object-sensitive+heap-A │ │ │ │ ├── analysis.logic │ │ │ │ ├── declarations.logic │ │ │ │ ├── delta.logic │ │ │ │ └── macros.logic │ │ │ ├── hybrid-2-full-object-sensitive+heap-B │ │ │ │ ├── analysis.logic │ │ │ │ ├── declarations.logic │ │ │ │ ├── delta.logic │ │ │ │ └── macros.logic │ │ │ ├── hybrid-2-full-object-sensitive+heap-C │ │ │ │ ├── analysis.logic │ │ │ │ ├── declarations.logic │ │ │ │ ├── delta.logic │ │ │ │ └── macros.logic │ │ │ ├── hybrid-2-full-object-sensitive+heap-D │ │ │ │ ├── analysis.logic │ │ │ │ ├── declarations.logic │ │ │ │ ├── delta.logic │ │ │ │ └── macros.logic │ │ │ ├── hybrid-2-full-object-sensitive+heap-E │ │ │ │ ├── analysis.logic │ │ │ │ ├── declarations.logic │ │ │ │ ├── delta.logic │ │ │ │ └── macros.logic │ │ │ ├── hybrid-2-full-object-sensitive+heap-F │ │ │ │ ├── analysis.logic │ │ │ │ ├── declarations.logic │ │ │ │ ├── delta.logic │ │ │ │ └── macros.logic │ │ │ ├── hybrid-2-full-object-sensitive+heap-I │ │ │ │ ├── analysis.logic │ │ │ │ ├── declarations.logic │ │ │ │ ├── delta.logic │ │ │ │ └── macros.logic │ │ │ ├── hybrid-2-full-object-sensitive+heap │ │ │ │ ├── analysis.logic │ │ │ │ ├── declarations.logic │ │ │ │ ├── delta.logic │ │ │ │ └── macros.logic │ │ │ ├── hybrid-2-type-sensitive+heap-B │ │ │ │ ├── analysis.logic │ │ │ │ ├── declarations.logic │ │ │ │ ├── delta.logic │ │ │ │ └── macros.logic │ │ │ ├── instancefield-experiment-dropped.logic │ │ │ ├── ref-2-call-site-sensitive+2-heap │ │ │ │ ├── analysis.logic │ │ │ │ ├── declarations.logic │ │ │ │ ├── delta.logic │ │ │ │ ├── macros.logic │ │ │ │ └── refinement-delta.logic │ │ │ ├── ref-2-call-site-sensitive+heap │ │ │ │ ├── analysis.logic │ │ │ │ ├── declarations.logic │ │ │ │ ├── delta.logic │ │ │ │ ├── macros.logic │ │ │ │ └── refinement-delta.logic │ │ │ ├── ref-2-object-sensitive+heap │ │ │ │ ├── analysis.logic │ │ │ │ ├── declarations.logic │ │ │ │ ├── delta.logic │ │ │ │ ├── macros.logic │ │ │ │ └── refinement-delta.logic │ │ │ ├── ref-2-type-sensitive+heap │ │ │ │ ├── analysis.logic │ │ │ │ ├── declarations.logic │ │ │ │ ├── delta.logic │ │ │ │ ├── macros.logic │ │ │ │ └── refinement-delta.logic │ │ │ ├── ref-3-object-sensitive+2-heap │ │ │ │ ├── analysis.logic │ │ │ │ ├── declarations.logic │ │ │ │ ├── delta.logic │ │ │ │ ├── macros.logic │ │ │ │ └── refinement-delta.logic │ │ │ └── thread-sensitive │ │ │ │ ├── analysis.logic │ │ │ │ ├── declarations.logic │ │ │ │ ├── delta.logic │ │ │ │ └── macros.logic │ │ └── sound-may-point-to │ │ │ └── old-analysis.logic │ └── basic │ │ └── exceptions │ │ ├── experimental-handler-no-order-declarations.logic │ │ ├── experimental-handler-no-order.logic │ │ ├── experimental-handler-order-declarations.logic │ │ └── experimental-handler-order.logic ├── facts │ ├── externalheaps.logic │ ├── flow-insensitive-schema.logic │ ├── flow-sensitive-schema.logic │ ├── import-dynamic-facts.logic │ ├── import-dynamic-facts2.logic │ ├── import-entities.logic │ ├── import-facts.logic │ ├── mock-heap.logic │ ├── post-process.logic │ └── to-flow-insensitive-delta.logic └── main │ ├── android.logic │ ├── class-initialization-declarations.logic │ ├── class-initialization.logic │ ├── classes-scc.logic │ ├── context-sensitivity-declarations.logic │ ├── context-sensitivity.logic │ ├── dynamicanalysis.logic │ ├── exceptions.logic │ ├── export-refinement.logic │ ├── finalization.logic │ ├── implicit-reachable-declarations.logic │ ├── implicit-reachable.logic │ ├── import-refinement.logic │ ├── in-out-flow.logic │ ├── main-declarations.logic │ ├── main-delta.logic │ ├── main.logic │ ├── method-handles.logic │ ├── native-delta.logic │ ├── native.logic │ ├── package-heuristic.logic │ ├── partitioning.logic │ ├── prologue.logic │ ├── reference.logic │ ├── reflection │ ├── declarations.logic │ ├── delta.logic │ ├── dynamic-proxies.logic │ ├── java.lang.Class.logic │ ├── java.lang.reflect.Array.logic │ ├── java.lang.reflect.Constructor.logic │ ├── java.lang.reflect.Field.logic │ ├── java.lang.reflect.Method.logic │ ├── proxyMacros.logic │ └── rules.logic │ ├── special-library.logic │ ├── string-constants-declarations.logic │ ├── string-constants.logic │ ├── threads-declarations.logic │ └── threads.logic ├── local-dependencies └── apktool-cli-2.4.2.jar ├── settings.gradle ├── souffle-logic ├── addons │ ├── butterknife.dl │ ├── cfg-analysis │ │ └── analysis.dl │ ├── constant-folding │ │ └── analysis.dl │ ├── dacapo │ │ └── rules.dl │ ├── glide.dl │ ├── information-flow │ │ ├── alfresco-sources-and-sinks.dl │ │ ├── android-sources-and-sinks.dl │ │ ├── android-taint-wrappers.dl │ │ ├── android.dl │ │ ├── beans-sources-and-sinks.dl │ │ ├── common-transfer-methods.dl │ │ ├── core.dl │ │ ├── declarations.dl │ │ ├── delta.dl │ │ ├── macros.dl │ │ ├── minimal-sources-and-sinks.dl │ │ ├── rules-data-flow.dl │ │ ├── rules.dl │ │ ├── spring-sources-and-sinks.dl │ │ └── webapps-sources-and-sinks.dl │ ├── open-programs │ │ ├── application-concrete-types.dl │ │ ├── entry-points.dl │ │ ├── rules-alfresco.dl │ │ ├── rules-beans.dl │ │ ├── rules-concrete-types.dl │ │ ├── rules-jackee.dl │ │ ├── rules-servlets-only.dl │ │ └── rules-spring.dl │ ├── opt-directives │ │ ├── directives.dl │ │ └── keep.dl │ ├── queries │ │ └── classifyVPT.dl │ ├── sanity.dl │ ├── sarif │ │ └── sarif.dl │ ├── scaler │ │ ├── max_context_calculator.dl │ │ └── non_precision_critical_methods.dl │ ├── server-logic │ │ ├── method-lookup-ext.dl │ │ ├── queries.dl │ │ └── type-hierarchy-ext.dl │ ├── souffle-incremental-output │ │ ├── functor-declarations.dl │ │ └── incr-output.dl │ ├── ssa-transform │ │ └── analysis.dl │ ├── statistics │ │ ├── macros.dl │ │ ├── metrics.dl │ │ ├── statistics-declarations.dl │ │ ├── statistics-output.dl │ │ ├── statistics-simple-declarations.dl │ │ ├── statistics-simple.dl │ │ └── statistics.dl │ ├── symbolic-reasoning │ │ ├── analysis.dl │ │ ├── arithmetic-reasoning.dl │ │ ├── boolean-reasoning.dl │ │ ├── declarations.dl │ │ ├── expr-tree.dl │ │ ├── path-expression.dl │ │ └── util.dl │ ├── tamiflex │ │ ├── declarations.dl │ │ ├── delta.dl │ │ ├── fact-declarations.dl │ │ ├── import.dl │ │ ├── post-import.dl │ │ └── rules.dl │ └── testing │ │ ├── AndroidTests_TypesOnly_androidterm.dl │ │ ├── TestInvokedynamic.dl │ │ ├── TestReflection.dl │ │ ├── native-tests.dl │ │ ├── test-discovery.dl │ │ └── test-exports.dl ├── analyses │ ├── 1-call-site-sensitive+heap │ │ └── analysis.dl │ ├── 1-call-site-sensitive │ │ └── analysis.dl │ ├── 1-object-1-type-sensitive+heap │ │ └── analysis.dl │ ├── 1-object-sensitive+heap │ │ └── analysis.dl │ ├── 1-object-sensitive │ │ └── analysis.dl │ ├── 1-type-sensitive+heap │ │ └── analysis.dl │ ├── 1-type-sensitive │ │ └── analysis.dl │ ├── 2-call-site-sensitive+2-heap │ │ └── analysis.dl │ ├── 2-call-site-sensitive+heap │ │ └── analysis.dl │ ├── 2-object-sensitive+2-heap │ │ └── analysis.dl │ ├── 2-object-sensitive+heap │ │ └── analysis.dl │ ├── 2-type-object-sensitive+2-heap │ │ └── analysis.dl │ ├── 2-type-object-sensitive+heap │ │ └── analysis.dl │ ├── 2-type-sensitive+heap │ │ └── analysis.dl │ ├── 3-object-sensitive+2-heap │ │ └── analysis.dl │ ├── 3-object-sensitive+3-heap │ │ └── analysis.dl │ ├── 3-type-sensitive+2-heap │ │ └── analysis.dl │ ├── 3-type-sensitive+3-heap │ │ └── analysis.dl │ ├── 4-object-sensitive+4-heap │ │ └── analysis.dl │ ├── adaptive-2-object-sensitive+heap │ │ └── analysis.dl │ ├── basic-only │ │ └── analysis.dl │ ├── blacklist-1-object-sensitive+heap │ │ └── analysis.dl │ ├── context-insensitive-plus │ │ └── analysis.dl │ ├── context-insensitive-plusplus │ │ └── analysis.dl │ ├── context-insensitive │ │ └── analysis.dl │ ├── data-flow │ │ ├── analysis.dl │ │ └── setup.dl │ ├── dependency-analysis │ │ ├── analysis.dl │ │ └── declarations.dl │ ├── dependency-context │ │ ├── 2objH-micro.dl │ │ ├── deco.dl │ │ └── self-contained.dl │ ├── fully-guided-context-sensitive │ │ └── analysis.dl │ ├── micro │ │ ├── analysis.dl │ │ └── self-contained.dl │ ├── oracular-precision │ │ └── analysis.dl │ ├── oracular-scalability │ │ └── analysis.dl │ ├── partitioned-2-object-sensitive+heap │ │ ├── analysis.dl │ │ └── partitioning.dl │ ├── selective-2-object-sensitive+heap │ │ └── analysis.dl │ ├── sound-may-point-to │ │ ├── analysis.dl │ │ ├── must-alias.dl │ │ └── must-point-to.dl │ ├── sticky-2-object-sensitive │ │ └── analysis.dl │ ├── types-only │ │ └── analysis.dl │ └── xtractor │ │ ├── analysis.dl │ │ ├── arrays.dl │ │ ├── common.dl │ │ ├── conditions.dl │ │ ├── constant-folding.dl │ │ ├── expr-client.dl │ │ ├── loops.dl │ │ ├── out-schema.dl │ │ ├── symbolic.dl │ │ └── theorem-prover.dl ├── basic │ ├── basic.dl │ ├── classes-scc.dl │ ├── exceptions.dl │ ├── finalization.dl │ ├── method-lookup.dl │ ├── method-resolution.dl │ ├── native-strings.dl │ ├── partitioning.dl │ └── type-hierarchy.dl ├── commonMacros.dl ├── facts │ ├── android.dl │ ├── facts.dl │ ├── flow-insensitive-facts.dl │ ├── flow-sensitive-schema.dl │ ├── generics.dl │ ├── import-dynamic-facts.dl │ ├── imports.dl │ ├── keep.dl │ └── opaque-methods.dl ├── main │ ├── android-declarations.dl │ ├── android-xml.dl │ ├── android.dl │ ├── api-mocking.dl │ ├── app-only.dl │ ├── basic-context-sensitivity.dl │ ├── class-initialization-declarations.dl │ ├── class-initialization.dl │ ├── configuration.dl │ ├── context-sensitivity-declarations.dl │ ├── context-sensitivity-variable-level.dl │ ├── context-sensitivity.dl │ ├── dynamicanalysis.dl │ ├── exceptions.dl │ ├── export.dl │ ├── finalization.dl │ ├── full-call-graph.dl │ ├── generics-pre-analysis.dl │ ├── implicit-reachable-declarations.dl │ ├── implicit-reachable.dl │ ├── in-out-flow.dl │ ├── init.dl │ ├── main-declarations.dl │ ├── main-delta.dl │ ├── main.dl │ ├── method-handles.dl │ ├── native.dl │ ├── non-segregated-rules.dl │ ├── package-heuristic.dl │ ├── phantom-dead.dl │ ├── prologue.dl │ ├── reference.dl │ ├── reflection │ │ ├── classloading.dl │ │ ├── declarations.dl │ │ ├── delta.dl │ │ ├── dynamic-proxies-delta.dl │ │ ├── dynamic-proxies.dl │ │ ├── java.lang.Class.dl │ │ ├── java.lang.reflect.Array.dl │ │ ├── java.lang.reflect.Constructor.dl │ │ ├── java.lang.reflect.Field.dl │ │ ├── java.lang.reflect.Method.dl │ │ ├── light-Class.dl │ │ ├── light-reflection-glue.dl │ │ ├── native-reflection.dl │ │ └── rules.dl │ ├── scaler-pre-analysis.dl │ ├── single-phase-analysis.dl │ ├── special-library.dl │ ├── string-concat.dl │ ├── string-constants.dl │ ├── threads-declarations.dl │ ├── threads.dl │ ├── two-phase-analysis.dl │ └── zipper-pre-analysis.dl └── python │ ├── addons │ └── statistics │ │ ├── statistics-macros.dl │ │ ├── statistics-output.dl │ │ ├── statistics-simple-declarations.dl │ │ └── statistics-simple.dl │ ├── analyses │ ├── 1-call-site-sensitive+heap │ │ └── analysis.dl │ ├── 1-call-site-sensitive │ │ └── analysis.dl │ ├── 2-call-site-sensitive+2-heap │ │ └── analysis.dl │ ├── 2-call-site-sensitive+heap │ │ └── analysis.dl │ └── context-insensitive │ │ └── analysis.dl │ ├── facts │ ├── import-entities.dl │ ├── import-facts.dl │ ├── post-process.dl │ └── schema.dl │ ├── lib-specific │ ├── default-python-lib.dl │ ├── lib-macros.dl │ ├── modeled.dl │ ├── numpy.dl │ └── tensorflow │ │ ├── arithmetic-ops.dl │ │ ├── general-tensor-modeling.dl │ │ ├── keras.dl │ │ ├── pooling-conv-ops.dl │ │ ├── shape-mod-ops.dl │ │ ├── shape-pass-through-ops.dl │ │ ├── tensor-creation-ops.dl │ │ ├── tensorflow-library.dl │ │ ├── tensorflow.dl │ │ └── uncategorized-ops.dl │ └── main │ ├── comprehension.dl │ ├── configuration.dl │ ├── const-int.dl │ ├── dictionaries.dl │ ├── export.dl │ ├── function-resolution-declarations.dl │ ├── function-resolution.dl │ ├── imports.dl │ ├── lists.dl │ ├── main-declarations.dl │ └── main.dl ├── src ├── inputTests │ ├── test0 │ │ └── A.java │ ├── test1 │ │ └── A.java │ ├── test2 │ │ └── A.java │ ├── test3 │ │ └── A.java │ ├── test4 │ │ └── A.java │ ├── test5 │ │ └── A.java │ ├── test6 │ │ └── A.java │ └── test7 │ │ └── A.java ├── main │ ├── groovy │ │ ├── TestScalerPredictions.groovy │ │ └── org │ │ │ └── clyze │ │ │ └── doop │ │ │ ├── Main.groovy │ │ │ ├── command │ │ │ ├── CommandLineAnalysisFactory.groovy │ │ │ ├── CommandLineAnalysisPostProcessor.groovy │ │ │ ├── GOption.groovy │ │ │ ├── Help.groovy │ │ │ └── HelpGroupFormatter.groovy │ │ │ ├── core │ │ │ ├── Doop.groovy │ │ │ ├── DoopAnalysis.groovy │ │ │ ├── DoopAnalysisFactory.groovy │ │ │ ├── DoopAnalysisFamily.groovy │ │ │ ├── FactGenerator0.groovy │ │ │ ├── FrontEnd.groovy │ │ │ ├── LB3Analysis.groovy │ │ │ ├── SouffleAnalysis.groovy │ │ │ ├── SouffleGenericsMultiPhaseAnalysis.groovy │ │ │ ├── SouffleOracularPrecisionMultiPhaseAnalysis.groovy │ │ │ ├── SouffleOracularScalabilityMultiPhaseAnalysis.groovy │ │ │ ├── SoufflePartitionedAnalysis.groovy │ │ │ ├── SoufflePythonAnalysis.groovy │ │ │ └── SouffleScalerMultiPhaseAnalysis.groovy │ │ │ ├── input │ │ │ ├── BenchmarksResolver.groovy │ │ │ └── RecursiveBenchmarksResolver.groovy │ │ │ └── utils │ │ │ ├── CPreprocessor.groovy │ │ │ ├── ConfigurationGenerator.groovy │ │ │ ├── ContextRemover.groovy │ │ │ ├── DDlog.groovy │ │ │ ├── LBBuilder.groovy │ │ │ ├── SouffleOptions.groovy │ │ │ ├── SouffleScript.groovy │ │ │ ├── SouffleScriptMain.groovy │ │ │ ├── TACGenerator.groovy │ │ │ ├── XTractor.groovy │ │ │ └── scaler │ │ │ ├── ScalerPostAnalysis.groovy │ │ │ └── WorstCaseContextMap.groovy │ ├── java │ │ └── org │ │ │ └── clyze │ │ │ └── doop │ │ │ ├── oracular │ │ │ └── CountOccurrences.java │ │ │ ├── ptatoolkit │ │ │ ├── Global.java │ │ │ ├── LICENSE-scaler-zipper │ │ │ ├── Options.java │ │ │ ├── doop │ │ │ │ ├── DataBase.java │ │ │ │ ├── Query.java │ │ │ │ ├── QueryResultItr.java │ │ │ │ ├── basic │ │ │ │ │ ├── DoopField.java │ │ │ │ │ ├── DoopInstanceCallSite.java │ │ │ │ │ ├── DoopInstanceMethod.java │ │ │ │ │ ├── DoopObj.java │ │ │ │ │ ├── DoopStaticMethod.java │ │ │ │ │ ├── DoopType.java │ │ │ │ │ └── DoopVariable.java │ │ │ │ └── factory │ │ │ │ │ ├── ElementFactory.java │ │ │ │ │ ├── FieldFactory.java │ │ │ │ │ ├── InstanceCallSiteFactory.java │ │ │ │ │ ├── MethodFactory.java │ │ │ │ │ ├── ObjFactory.java │ │ │ │ │ ├── TypeFactory.java │ │ │ │ │ └── VariableFactory.java │ │ │ ├── pta │ │ │ │ ├── basic │ │ │ │ │ ├── AttributeElement.java │ │ │ │ │ ├── BasicElement.java │ │ │ │ │ ├── CallSite.java │ │ │ │ │ ├── Field.java │ │ │ │ │ ├── InstanceCallSite.java │ │ │ │ │ ├── InstanceMethod.java │ │ │ │ │ ├── Method.java │ │ │ │ │ ├── Obj.java │ │ │ │ │ ├── StaticMethod.java │ │ │ │ │ ├── Type.java │ │ │ │ │ └── Variable.java │ │ │ │ └── util │ │ │ │ │ └── Numberable.java │ │ │ ├── scaler │ │ │ │ ├── Driver.java │ │ │ │ ├── analysis │ │ │ │ │ ├── ContextComputer.java │ │ │ │ │ ├── ObjectAllocationGraph.java │ │ │ │ │ ├── Scaler.java │ │ │ │ │ ├── ScalerRank.java │ │ │ │ │ ├── _1TypeContextComputer_Scaler.java │ │ │ │ │ ├── _1TypeContextComputer_ScalerPlus.java │ │ │ │ │ ├── _2ObjectContextComputer_Scaler.java │ │ │ │ │ ├── _2ObjectContextComputer_ScalerPlus.java │ │ │ │ │ ├── _2TypeContextComputer_Scaler.java │ │ │ │ │ ├── _2TypeContextComputer_ScalerPlus.java │ │ │ │ │ └── _InsensitiveContextComputer.java │ │ │ │ ├── doop │ │ │ │ │ ├── Attribute.java │ │ │ │ │ ├── DoopPointsToAnalysis.java │ │ │ │ │ ├── MethodFactory.java │ │ │ │ │ └── ObjFactory.java │ │ │ │ └── pta │ │ │ │ │ └── PointsToAnalysis.java │ │ │ └── util │ │ │ │ ├── ANSIColor.java │ │ │ │ ├── MutableInteger.java │ │ │ │ ├── MutableLong.java │ │ │ │ ├── Pair.java │ │ │ │ ├── SetFactory.java │ │ │ │ ├── Timer.java │ │ │ │ ├── Triple.java │ │ │ │ └── graph │ │ │ │ └── DirectedGraph.java │ │ │ └── util │ │ │ └── ClassPathHelper.java │ └── resources │ │ ├── .gitignore │ │ ├── AndroidCallbacks.txt │ │ ├── EasyTaintWrapperSource.txt │ │ ├── log4j.properties │ │ └── timeout └── test │ ├── groovy │ └── org │ │ └── clyze │ │ └── doop │ │ ├── AndroidTests.groovy │ │ ├── Artifacts.groovy │ │ ├── CrudeLBTest.groovy │ │ ├── CrudeMicroTest.groovy │ │ ├── CrudeScalerTest.groovy │ │ ├── CrudeSouffleTest.groovy │ │ ├── CrudeWalaTest.groovy │ │ ├── DataFlowTest.groovy │ │ ├── DoopBenchmark.groovy │ │ ├── DoopSpec.groovy │ │ ├── DryRuns.groovy │ │ ├── InformationFlowTest.groovy │ │ ├── MiscAnalysisTests.groovy │ │ ├── MiscLambdaTests.groovy │ │ ├── OpenProgramsAndHeapDL.groovy │ │ ├── OpenProgramsTest.groovy │ │ ├── PlatformTest.groovy │ │ ├── PythonTest.groovy │ │ ├── ServerAnalysisTests.groovy │ │ ├── SimpleAnalysisTests.groovy │ │ ├── TestClassicReflection.groovy │ │ ├── TestDifferentialDatalog.groovy │ │ ├── TestFactsReuse.groovy │ │ ├── TestFactsSubset.groovy │ │ ├── TestInvokedynamic.groovy │ │ ├── TestLambdasMethodReferences.groovy │ │ ├── TestLightReflection.groovy │ │ ├── TestNativeCode.groovy │ │ ├── TestSoundMayPointsTo.groovy │ │ ├── TestUtils.groovy │ │ ├── WarTest.groovy │ │ └── util │ │ └── PackageUtilsTest.groovy │ └── resources │ ├── java11-string-concat.jar │ ├── keep-spec │ └── keep-spec-android.txt │ └── scenarios │ ├── antlr-1call-tamiflex-lb.properties │ ├── antlr-1call-tamiflex.properties │ ├── antlr-1objH-tamiflex-lb.properties │ ├── antlr-1objH-tamiflex.properties │ ├── antlr-insensitive-reflection-lb.properties │ ├── antlr-insensitive-reflection.properties │ ├── antlr-insensitive-tamiflex-lb.properties │ └── antlr-insensitive-tamiflex.properties └── tests ├── 016-reflection ├── build.gradle └── src │ └── main │ └── java │ ├── AnnotationsTest.java │ ├── Main.java │ └── ReflectionTest.java ├── 104-method-references ├── build.gradle ├── src │ └── main │ │ └── java │ │ ├── Main.java │ │ ├── MethodReferencesTest.java │ │ └── Person.java └── standalone_settings.gradle ├── 107-lambdas ├── build.gradle ├── src │ └── main │ │ └── java │ │ └── Main.java └── standalone_settings.gradle └── 115-invokedynamic ├── README.md ├── build.gradle ├── src └── main │ └── java │ ├── A.java │ └── Main.java └── standalone_settings.gradle /.gitignore: -------------------------------------------------------------------------------- 1 | .gradle 2 | .gradletasknamecache 3 | build 4 | cache 5 | logs 6 | out 7 | results 8 | last-analysis 9 | checksums.properties 10 | doop.properties 11 | src/main/resources/git-hash.txt 12 | src/test/resources/AndroidCallbacks.txt 13 | src/test/resources/EasyTaintWrapperSource.txt 14 | src/test/resources/apktool-cli-2.4.2.jar 15 | src/test/resources/git-hash.txt 16 | src/test/resources/log4j.properties 17 | src/test/resources/timeout 18 | src/test/resources/*-fact-generator.jar 19 | # dynamically generated class 20 | tests/115-invokedynamic/InvokedynamicClass.class 21 | 22 | #intellij idea files 23 | .idea 24 | doop-nexgen.iml 25 | 26 | #eclipse files 27 | .classpath 28 | .project 29 | 30 | #netbeans files 31 | .nb-gradle 32 | 33 | #vs-code files 34 | .vscode 35 | 36 | #emacs files 37 | *~ 38 | \#*\# 39 | .\#* 40 | 41 | #swp files 42 | *.swp 43 | 44 | #souffle profiler html output dir 45 | profiler_html 46 | 47 | 48 | *.class -------------------------------------------------------------------------------- /COLLABORATORS: -------------------------------------------------------------------------------- 1 | Anastasios Antoniadis 2 | George Balatsouras 3 | Martin Bravenboer 4 | Kostas Ferles 5 | Neville Grech 6 | George Kastrinis 7 | Jim Mouris 8 | Konstantinos Triantafyllou 9 | Kostas Saidis 10 | George Fourtounis 11 | Sifis Lagouvardos 12 | Yue Li 13 | Tian Tan 14 | Anders Møller 15 | Yannis Smaragdakis 16 | -------------------------------------------------------------------------------- /LICENSE-doop-orig: -------------------------------------------------------------------------------- 1 | Copyright (C) 2008-2009 Martin Bravenboer 2 | 3 | Permission is hereby granted, free of charge, to any person 4 | obtaining a copy of this software and associated documentation 5 | files (the "Software"), to deal in the Software without 6 | restriction, including without limitation the rights to use, 7 | copy, modify, merge, publish, distribute, sublicense, and/or sell 8 | copies of the Software, and to permit persons to whom the 9 | Software is furnished to do so, subject to the following 10 | conditions: 11 | 12 | The above copyright notice and this permission notice shall be 13 | included in all copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 16 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 17 | OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 18 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 19 | HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 20 | WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 21 | FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 22 | OTHER DEALINGS IN THE SOFTWARE. 23 | -------------------------------------------------------------------------------- /bin/android-check.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | IN=$ANDROID_IN 4 | OUT=$ANDROID_OUT 5 | 6 | echo ${IN} 7 | echo ${OUT} 8 | 9 | for file in ${IN}/*.facts; do 10 | file=$(basename "${file}") 11 | 12 | if [ ! -f "${OUT}/database/${file}" ]; then 13 | echo ${file} 14 | fi 15 | done 16 | -------------------------------------------------------------------------------- /bin/db-analyser.py: -------------------------------------------------------------------------------- 1 | #! /usr/bin/python 2 | 3 | """Database analysis results anayser 4 | 5 | Usage: 6 | db-analyser.py --delta 7 | 8 | Options: 9 | -h --help Show this screen. 10 | --version Show version. 11 | 12 | """ 13 | from docopt import docopt 14 | import subprocess 15 | import pandas as pd 16 | 17 | def getProcess(db): 18 | process = subprocess.run(['bloxbatch', '-db', db, '-popCount'], stdout=subprocess.PIPE, universal_newlines=True) 19 | return process 20 | 21 | def parseOut(out): 22 | res = {} 23 | for line in out.split('\n'): 24 | linesplit = line.split(': ') 25 | try: 26 | res[linesplit[0]] = int(linesplit[1]) 27 | except Exception: 28 | pass 29 | return pd.Series(res) 30 | 31 | 32 | if __name__ == '__main__': 33 | arguments = docopt(__doc__, version='0.1') 34 | ratios = ((parseOut(getProcess(arguments['']).stdout) * 1.0) 35 | / parseOut(getProcess(arguments['']).stdout)) 36 | pd.set_option('display.max_rows', len(ratios)) 37 | print(ratios.sort_values()) 38 | 39 | -------------------------------------------------------------------------------- /bin/facts-to-json.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | 3 | import csv 4 | import sys 5 | 6 | if (len(sys.argv) < 2): 7 | print("Usage: facts-to-json.py file.facts") 8 | exit(0) 9 | 10 | with open(sys.argv[1], 'rb') as csvfile: 11 | totalRows = sum(1 for line in csvfile) 12 | 13 | with open(sys.argv[1], 'rb') as csvfile: 14 | r = csv.reader(csvfile, delimiter="\t") 15 | rowNum = 0 16 | print("[\n") 17 | for row in r: 18 | rowNum = rowNum + 1 19 | fields = [] 20 | count = 0 21 | for field in row: 22 | fields = fields + ['"field' + str(count) + '" : "' + field + '"'] 23 | count = count + 1 24 | sep = ",\n" if rowNum < totalRows else "" 25 | print("{ " + ", ".join(fields) + " }" + sep) 26 | print("]") 27 | -------------------------------------------------------------------------------- /bin/mkjar: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | [[ $# != 3 ]] && echo "Usage: " && exit 4 | 5 | filenameJava=$1 6 | filename=${filenameJava%.*} 7 | filenameJar=${filename}.jar 8 | outDir=$3 9 | 10 | tmpDir=$(mktemp -d) 11 | 12 | # If we need to use a specific jre version do the following (instead of the 13 | # previous javac command). But, is it needed since we will use a specific jre 14 | # to analyze anyway? 15 | jreDir=$DOOP_PLATFORMS_LIB/JREs 16 | if [ -d $jreDir ] ; then 17 | jre=$2 18 | javac $filenameJava -d $tmpDir -g -bootclasspath ${jreDir}/jre${jre}/lib/rt.jar -source $jre -target $jre 19 | else 20 | javac $filenameJava -d $tmpDir -g 21 | fi 22 | 23 | jar cvfe $filenameJar $filename -C $tmpDir . 24 | rm -rf $tmpDir 25 | 26 | echo "Moving generated jar file into $outDir" 27 | mv $filenameJar $outDir 28 | -------------------------------------------------------------------------------- /bin/run-with-redirection.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | if [ "$1" == "" ] || [ "$2" == "" ] || [ "$3" == "" ]; then 4 | echo "Usage: run-with-redirection.sh INPUT OUTPUT CMD..." 5 | exit 6 | fi 7 | 8 | INPUT=$1 9 | OUTPUT=$2 10 | shift 2 11 | eval "$*" < ${INPUT} &> ${OUTPUT} 12 | -------------------------------------------------------------------------------- /bin/souffleScript: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # Args: