Typos

Author: Dominik Helm

CONTRIBUTING.md

@@ -29,7 +29,7 @@ Do not use Scala's feature to import multiple classes/objects from the same pack
 (This behavior can be configured in *IntelliJ*)
 
 ## Do Not Use Wildcard Imports
-Do not used wildcard imports, e.g., `import scala.collection._`, unless you import a huge (> 48) number of classes for the same package. Such imports are very brittle and can lead to strange behavior.
+Do not use wildcard imports, e.g., `import scala.collection._`, unless you import a huge (> 48) number of classes for the same package. Such imports are very brittle and can lead to strange behavior.
 
 (This behavior can be configured in *IntelliJ*)
 

Changes.md

@@ -90,9 +90,9 @@
 ## 3.0.0 - Snapshot available since June 7th, 2019
 
 - added a preliminary IFDS framework
-- the Hermes and BugPicker UI projects were deleted (JavaFX was removed from the JDK 11 which makes the overall development and deplyoment process to cost intensive)
+- the Hermes and BugPicker UI projects were deleted (JavaFX was removed from the JDK 11 which makes the overall development and deployment process to cost intensive)
 - Hermes was promoted to a real project: TOOLS/hermes
-- renamed `DefaultOneStepAnalysis` to `ProjectAnalysisApplication`; added a new subclass `MethodAnalysisApplication` to facilitate the developmen of respective analysis
+- renamed `DefaultOneStepAnalysis` to `ProjectAnalysisApplication`; added a new subclass `MethodAnalysisApplication` to facilitate the development of respective analysis
 - added support for analyses using the monotone framework; the monotone framework itself was added to `CFG`
 - the three-address code has been moved to its own subproject (`ThreeAddressCode`) in the folder OPAL/tac
 - fixed the name of the static analysis infrastructure project (the name of the project on Maven Central has changed)
@@ -119,7 +119,7 @@
 ## 2.0.1 - Released Oct. 10th 2018
 
 - fixed a bug in the identification of closed strongly connected components
-- fixed a bug when computing the stackmap table when a register store instruction is found in a try block of a finally handler and therefore is considered to be throwing an exception by the VM when it tries to verify the bytecode
+- fixed a bug when computing the stackmap table when a register store instruction is found in a try block of a finally-handler and therefore is considered to be throwing an exception by the VM when it tries to verify the bytecode
 - fixed a bug when a simple property of an entity is queried in a later phase (after the analysis was run) and the analysis didn't compute a value
 
 ## 2.0.0 - Released Oct. 2nd 2018
@@ -130,13 +130,13 @@
 - support for Java 11
 - rewriting StringConcatFactory based invokedynamics
 - support for analyzing Scala 2.12.6-7 invokedynamics
-- Hermes now has extended visualization capabilities to make it even easiere to comprehend the differences between projects
-- the overall performance has been improved (in particular on multi-core systems with 4 or more cores)
+- Hermes now has extended visualization capabilities to make it even easier to comprehend the differences between projects
+- the overall performance has been improved (in particular on multicore systems with 4 or more cores)
 - moved to sbt 1.2.x
 - fixed issues in some tests which open a huge number of files
 - fixed a rare issue in the identification of closed strongly connected components
 - completely reimplemented the property store
-  - added various analyses related to deriving the purity of methods, the immutabiliy of classes, escape information etc.
+  - added various analyses related to deriving the purity of methods, the immutability of classes, escape information etc.
 - very much improved OPAL's collection library w.r.t. optimized data structures for Int values
 
 ## 1.0.0 - Released Oct. 25th 2017
@@ -162,9 +162,9 @@
 ### General
 
 - the call graph construction algorithms finally completely support Java 8 (e.g., default methods, static methods in interfaces, lambda expressions)
-- ***Assertions are turned-off by default when you checkout the latest stable release of OPAL***; to turn them on rename `local.sbt.template` to `local.sbt`; assertions are still turned on, when you depend on a development snapshot from Maven Central
-- removed the Eclipse plug-in sub-project; it wasn't maintained anymore and is now replaced by the ATOM plug-in
-- removed the Viz sub-project; it wasn't maintained anymore and OPAL has gained the possibility to generate SVGs using [a JavaScript based Graphviz version](https://github.com/mdaines/viz.js) which is executed using JDK's Nashorn JavaScript engine
+- ***Assertions are turned-off by default when you check out the latest stable release of OPAL***; to turn them on rename `local.sbt.template` to `local.sbt`; assertions are still turned on, when you depend on a development snapshot from Maven Central
+- removed the Eclipse plug-in subproject; it wasn't maintained anymore and is now replaced by the ATOM plug-in
+- removed the Viz subproject; it wasn't maintained anymore and OPAL has gained the possibility to generate SVGs using [a JavaScript based Graphviz version](https://github.com/mdaines/viz.js) which is executed using JDK's Nashorn JavaScript engine
 - fixed several minor bugs and issues when analyzing bytecode which contains compile-time dead code; the Groovy compiler frequently generated (generates?) such code
 - renamed packages called "analysis" to "analyses"
 
@@ -229,7 +229,7 @@
 - the AI now prevents simple, unnecessary joins if a variable is known to be dead when multiple control flow paths join
 - added a simple live variables analysis to `br.Code.liveVariables` which computes liveness information for a code's locals (operand stack values are not considered because standard compilers generally don't create "dead operands" and the intended usage are performance and precision improvements)
 - refined the implementations of Graphs
-- added efficient implementatin of Tarjan's algorithm for finding strongly connected components (the implementation can easily handle graphs with millions of nodes)
+- added efficient implementation of Tarjan's algorithm for finding strongly connected components (the implementation can easily handle graphs with millions of nodes)
 - added support for converting dot files to SVG using vis-js.com
 - completely reworked `org.opalj.collection.immmutable.UIDSet`; instead of a simple binary search tree - which had significant scalability issues - we are now using a trie.
 - initial release of Hermes

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/ai/CipherGetInstanceStrings.scala

@@ -21,7 +21,7 @@ import org.opalj.br.instructions.INVOKESTATIC
 import org.opalj.br.instructions.LoadString
 
 /**
- * The analysis demonstrates how to find values passed to Chipher.getInstance:
+ * The analysis demonstrates how to find values passed to Cipher.getInstance:
  * {{{
  * static Chipher getInstance(String transformation)
  * static Cipher  getInstance(String transformation, Provider provider)
@@ -66,7 +66,7 @@ object CipherGetInstanceStrings extends ProjectsAnalysisApplication {
                     case invoke @ INVOKEINTERFACE(ClassType.JavaSecurityKey, "getAlgorithm", JustReturnsString) =>
                         report.add(m.toJava(s"return value of ($pc): ${invoke.toString}"))
 
-                    case get @ GETFIELD(_, _, _) => println("uknown value: " + get)
+                    case get @ GETFIELD(_, _, _) => println("known value: " + get)
                     case i                       => println("unsupported instruction: " + i)
                 }
             }

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/ai/InfiniteRecursions.scala

@@ -76,7 +76,7 @@ object InfiniteRecursions extends ProjectsAnalysisApplication {
                     }
                 }
                 if pcs.nonEmpty
-                result <- inifiniteRecursions(maxRecursionDepth, project, method, pcs)
+                result <- infiniteRecursions(maxRecursionDepth, project, method, pcs)
             } yield { result }
 
         (project, BasicReport(result.map(_.toString).mkString("\n")))
@@ -89,7 +89,7 @@ object InfiniteRecursions extends ProjectsAnalysisApplication {
      * `maxRecursionDepth` determines after how many non-recursive calls the analysis
      * is aborted.
      */
-    def inifiniteRecursions(
+    def infiniteRecursions(
         maxRecursionDepth: Int,
         project:           SomeProject,
         method:            Method,
@@ -116,7 +116,7 @@ object InfiniteRecursions extends ProjectsAnalysisApplication {
                 if operandsArray(pc) ne null
                 nextCallOperands: domain.Operands = operandsArray(pc).take(parametersCount)
             } {
-                // IntegerRangeValues and ReferenceValues have useable equals semantics
+                // IntegerRangeValues and ReferenceValues have usable equals semantics
                 if (!callOperandsList.contains(nextCallOperands))
                     callOperandsList = nextCallOperands :: callOperandsList
             }

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/ai/domain/l0/ParameterUsageAnalysis.scala

@@ -90,11 +90,11 @@ object ParameterUsageAnalysis extends ProjectsAnalysisApplication {
 
         } { t => analysisTime = t.toSeconds }
 
-        val occurences = returnedParameters.size
+        val occurrences = returnedParameters.size
         val report = BasicReport(
             returnedParameters.mkString("Directly returned parameters:\n", "\n", "\n\n") +
                 unusedParameters.mkString("Unused parameters:\n", "\n", "\n\n") +
-                s"\nThe analysis took $analysisTime and found $occurences direct returns"
+                s"\nThe analysis took $analysisTime and found $occurrences direct returns"
         )
         (project, report)
     }

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/ai/domain/l1/MethodReturnValuesAnalysis.scala

@@ -88,7 +88,7 @@ object MethodReturnValuesAnalysis extends ProjectsAnalysisApplication {
                     }
                 }
 
-            // Test if it make sense to continue the abstract interpretation or if the
+            // Test if it makes sense to continue the abstract interpretation or if the
             // return value information is already not more precise than the "return type".
             theReturnedValue match {
                 case rv @ TypeOfReferenceValue(UIDSet1(`originalReturnType`))

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/ba/ThirdInstrumentation.scala

@@ -53,8 +53,8 @@ object ThirdInstrumentation extends App {
 
     val TheType = ClassType("org/opalj/ba/SimpleInstrumentationDemo")
 
-    // Let's load the class ( we need the RT Jar to compute appropriate supertypes for
-    // local variables and stack values during instrumentation.
+    // Let's load the class (we need JavaBase to compute appropriate supertypes for
+    // local variables and stack values during instrumentation).
     val f = new File(this.getClass.getResource("SimpleInstrumentationDemo.class").getFile)
     val p = Project(f.getParentFile, org.opalj.bytecode.JavaBase)
     implicit val classHierarchy: ClassHierarchy = p.classHierarchy // STRICTLY REQUIRED WHEN A StackMapTable NEEDS TO BE COMPUTED!
@@ -113,10 +113,10 @@ object ThirdInstrumentation extends App {
                 // whenever a method is called, we output its signature
                 lCode.insert(
                     // Note, we generally don't want to use Before, here!
-                    // If we would use "Before" and would have a method like:
+                    // If we used "Before" and would have a method like:
                     // do {
                     // } while(...)
-                    // It could happen that the output would be printed each time the loop
+                    // , it could happen that the output would be printed each time the loop
                     // is evaluated.
                     0,
                     InsertionPosition.At,
@@ -164,7 +164,7 @@ object ThirdInstrumentation extends App {
                         Seq(
                             DUP, // duplicate the value
                             GETSTATIC(SystemType, "out", PrintStreamType), // receiver
-                            SWAP, // the int value is on top now..
+                            SWAP, // the int value is on top now...
                             IFGT(gtTarget),
                             // value is less than 0
                             LoadString("negative"), // top is the parameter, receiver is 2nd top most
@@ -230,7 +230,7 @@ object ThirdInstrumentation extends App {
             if (!ite.getCause.isInstanceOf[RuntimeException]) {
                 Console.err.println("Big Bug!")
             } else {
-                Console.out.println("Dead code successfully removedt!")
+                Console.out.println("Dead code successfully removed!")
             }
     }
 }

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/bc/DAandBR.scala

@@ -216,7 +216,7 @@ object DAandBR extends App {
     val brClassFile = Java8Framework.ClassFile(() => new ByteArrayInputStream(assembledCF)).head
     val newBRMethods =
         brClassFile.methods
-            .filter(m => /*due some sophisticated analysis...*/ m.name == "<init>")
+            .filter(m => /* do some sophisticated analysis...*/ m.name == "<init>")
             .map[MethodTemplate](m => m.copy())
     val newBRClassFile = brClassFile.copy(methods = newBRMethods)
 

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/br/FieldAccessInformationAnalysis.scala

@@ -89,7 +89,7 @@ object FieldAccessInformationAnalysis extends ProjectsAnalysisApplication {
             } else {
                 BasicReport(
                     accessInformation.statistics
-                        .mkString(s"determing field access information required $memoryUsage :\n", "\n", "\n")
+                        .mkString(s"determining field access information required $memoryUsage :\n", "\n", "\n")
                 )
             }
 

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/br/OverridingMethodsCount.scala

@@ -40,7 +40,7 @@ object OverridingMethodsCount extends ProjectsAnalysisApplication {
                     val overridingMethods = allOverridingMethods.map(m => m.classFile.fqn)
                     val count = overridingMethods.size
                     method.toJava(
-                        overridingMethods.mkString(s"\n\thas $count overridde(s):\n\t\t", "\n\t\t", "\n")
+                        overridingMethods.mkString(s"\n\thas $count override(s):\n\t\t", "\n\t\t", "\n")
                     )
                 }