info/labs/lab04/test/resources/typer/passing/IfWithError.grading.amy

+object If
+  val a: Int(32) = if (true) { error("") } else { error("") };
+  val x: Int(32) = if (true) { 1 } else { 2 };
+  x
+end If

info/labs/lab04/test/resources/typer/passing/LetWithError.grading.amy

+object LetWithError
+  val y: Int(32) = (val x: Int(32) = 1; error("this is fine"));
+  y
+end LetWithError
\ No newline at end of file

info/labs/lab04/test/resources/typer/passing/Logical.grading.amy

+object Logical
+  true || false && !false
+end Logical

info/labs/lab04/test/resources/typer/passing/Match1.grading.amy

+object Match1
+  1 match {
+    case _ => ()
+  }
+end Match1

info/labs/lab04/test/resources/typer/passing/Match2.grading.amy

+object Match2
+  1 match {
+    case x => x + 1
+  }
+end Match2

info/labs/lab04/test/resources/typer/passing/Match3.grading.amy

+object Constructors
+  abstract class Foo 
+  case class Bar(i: Int(32)) extends Foo
+  case class Baz(b: Boolean, f: Foo) extends Foo
+
+  abstract class Foo2
+  case class Bar2(i: Int(32)) extends Foo2
+  case class Baz2(b: Boolean, f: Foo2) extends Foo2
+
+  val x: Boolean = Bar(1) match {
+    case Bar(1) => true
+    case Baz(x, Baz(y, Bar(z))) =>
+      x || y && z < 0
+    case Baz(_, Bar(_)) => false
+  };
+  x
+end Constructors

info/labs/lab04/test/resources/typer/passing/MatchWithError.grading.amy

+object Match2
+  val a: Int(32) = 1 match {
+    case x => error("")
+  };
+  a
+end Match2

info/labs/lab04/test/resources/typer/passing/Misc.grading.amy

+object Misc
+  error("a" ++ "b")
+end Misc

info/labs/lab04/test/resources/typer/passing/Seq.grading.amy

+object Seq
+  val x: Boolean = (2; true); x
+end Seq

info/labs/lab04/test/resources/typer/passing/SeqWithError.grading.amy

+object SeqWithError
+  val x: Int(32) = (1 + 2; error("this is fine"));
+  x
+end SeqWithError

info/labs/lab04/test/scala/amyc/test/CompilerTest.scala

+package amyc.test
+
+import amyc.utils._
+import java.io.File
+
+import org.junit.Assert.fail
+
+abstract class CompilerTest extends TestUtils {
+  private def runPipeline(pipeline: Pipeline[List[File], Unit], fileNames: List[String]) = {
+    val ctx = Context(new Reporter, fileNames)
+    val files = ctx.files.map(new File(_))
+    pipeline.run(ctx)(files)
+    ctx.reporter.terminateIfErrors()
+  }
+
+  private def runPipelineRedirected(
+    pipeline: Pipeline[List[File], Unit],
+    compiledFiles: List[String],
+    input: String
+  ): String = {
+    testWithRedirectedIO(runPipeline(pipeline, compiledFiles), input)
+  }
+
+  private def assertEqual(output: String, expected: String) = {
+    val rejectLine = (s: String) =>
+      s.isEmpty ||
+        s.startsWith("[ Info  ]") ||
+        s.startsWith("[Warning]") ||
+        s.startsWith("[ Error ]") ||
+        s.startsWith("[ Fatal ]")
+    def filtered(s: String) = s.linesIterator.filterNot(rejectLine).mkString("\n")
+    val filteredOutput = filtered(output)
+    val filteredExpected = filtered(expected)
+    if (filteredOutput != filteredExpected) {
+      val sb = new StringBuffer()
+      sb.append("\nOutput is different:\n")
+      sb.append("\nOutput: \n")
+      sb.append(filteredOutput)
+      sb.append("\n\nExpected output: \n")
+      sb.append(filteredExpected)
+      sb.append("\n")
+      fail(sb.toString)
+    }
+  }
+
+  protected def compareOutputs(
+    pipeline: Pipeline[List[File], Unit],
+    compiledFiles: List[String],
+    expectedFile: String,
+    input: String = ""
+  ) = {
+    try {
+      val output = runPipelineRedirected(pipeline, compiledFiles, input)
+      val expected = scala.io.Source.fromFile(new File(expectedFile)).mkString
+      assertEqual(output, expected)
+    } catch {
+      // We only want to catch AmyFatalError gracefully, the rest can propagate
+      case AmycFatalError(msg) =>
+        fail(s"\n  $msg\n")
+    }
+  }
+
+  protected def demandPass(
+    pipeline: Pipeline[List[File], Unit],
+    compiledFiles: List[String],
+    input: String = ""
+  ) = {
+    try {
+      runPipelineRedirected(pipeline, compiledFiles, input)
+    } catch {
+      case AmycFatalError(msg) =>
+        fail(s"\n  $msg\n")
+    }
+  }
+
+  protected def demandFailure(
+    pipeline: Pipeline[List[File], Unit],
+    compiledFiles: List[String],
+    input: String = ""
+  ) = {
+    try {
+      runPipelineRedirected(pipeline, compiledFiles, input)
+      fail("Test should fail but it passed!")
+    } catch {
+      case AmycFatalError(_) =>
+      // Ok, this is what we wanted. Other exceptions should propagate though
+    }
+
+  }
+
+
+}

info/labs/lab04/test/scala/amyc/test/LexerTests.scala

+package amyc.test
+
+import amyc.parsing._
+import org.junit.Test
+
+class LexerTests extends TestSuite {
+  val pipeline = AmyLexer.andThen(DisplayTokens)
+
+  val baseDir = "lexer"
+
+  val outputExt = "txt"
+
+  @Test def testKeywords = shouldOutput("Keywords")
+
+  @Test def testIdentifiers = shouldOutput("Identifiers")
+
+  @Test def testOperators = shouldOutput("Operators")
+
+  @Test def testDelimiters = shouldOutput("Delimiters")
+
+  @Test def testCombinations = shouldOutput("Combinations")
+
+  @Test def testComments = shouldOutput("Comments")
+
+  @Test def testIntLiterals = shouldOutput("IntLiterals")
+
+  @Test def testStringLiterals = shouldOutput("StringLiterals")
+
+  @Test def testTwoFiles = shouldOutput(List("Keywords", "Operators"), "TwoFiles")
+
+  @Test def testSingleAmp = shouldFail("SingleAmp")
+
+  @Test def testSingleBar = shouldFail("SingleBar")
+
+  @Test def testUnclosedComment = shouldFail("UnclosedComment")
+
+  @Test def testUnclosedComment2 = shouldFail("UnclosedComment2")
+
+  @Test def testUnclosedComment3 = shouldFail("UnclosedComment3")
+
+  @Test def testCommentClosedTwice = shouldOutput("CommentClosedTwice")
+
+  @Test def testUnclosedString1 = shouldFail("UnclosedString1")
+
+  @Test def testUnclosedString2 = shouldFail("UnclosedString2")
+
+  @Test def testInvalid = shouldFail("Invalid")
+
+  @Test def testTooBigInt = shouldFail("TooBigInt")
+
+  @Test def testWhitespace = shouldOutput("Whitespace")
+
+}

info/labs/lab04/test/scala/amyc/test/NameAnalyzerTests.scala

+package amyc.test
+
+import amyc.parsing._
+import amyc.ast.{Identifier, SymbolicPrinter}
+import amyc.ast.SymbolicTreeModule.Program
+import amyc.analyzer.{NameAnalyzer, SymbolTable}
+import amyc.utils._
+import org.junit.Test
+import scala.language.implicitConversions
+
+class NameAnalyzerTests extends TestSuite {
+  // A little hackery to overcome that Identifier names do not refresh over pipeline runs...
+  private class TestUniquePrinter extends SymbolicPrinter {
+    private val counter = new UniqueCounter[String]
+    private val map = scala.collection.mutable.Map[Identifier, Int]()
+    override implicit def printName(name: Identifier)(implicit printUniqueIds: Boolean): Document = {
+      if (printUniqueIds) {
+        val id = map.getOrElseUpdate(name, counter.next(name.name))
+        s"${name.name}_$id"
+      } else {
+        name.name
+      }
+    }
+  }
+
+  private val treePrinterS: Pipeline[(Program, SymbolTable), Unit] = {
+    new Pipeline[(Program, SymbolTable), Unit] {
+      def run(ctx: Context)(v: (Program, SymbolTable)) = {
+        println((new TestUniquePrinter)(v._1)(true))
+      }
+    }
+  }
+
+  val pipeline = AmyLexer.andThen(Parser).andThen(NameAnalyzer).andThen(treePrinterS)
+
+  val baseDir = "nameAnalyzer"
+
+  val outputExt = "scala"
+
+  @Test def testClasses = shouldOutput("Classes")
+  @Test def testConstructorVsIdPattern = shouldOutput("ConstructorVsIdPattern")
+  @Test def testDefOrder = shouldOutput("DefOrder")
+  @Test def testDuplicateClassParams = shouldOutput("DuplicateClassParams")
+  @Test def testNotDuplicateLocals1 = shouldOutput("NotDuplicateLocals1")
+  @Test def testNotDuplicateLocals2 = shouldOutput("NotDuplicateLocals2")
+  @Test def testParamAndLocal = shouldOutput("ParamAndLocal")
+  @Test def testRecursive = shouldOutput("Recursive")
+  @Test def testList = shouldOutput(List("List", "Std", "Option"), "List")
+  @Test def matchShadowParameter = shouldOutput("MatchShadowParameter")
+
+  @Test def testArgumentNumberFunction = shouldFail("ArgumentNumberFunction")
+  @Test def testArgumentNumberConstructor = shouldFail("ArgumentNumberConstructor")
+  @Test def testArgumentNumberPattern = shouldFail("ArgumentNumberPattern")
+  @Test def testDuplicateDefs1 = shouldFail("DuplicateDefs1")
+  @Test def testDuplicateDefs2 = shouldFail("DuplicateDefs2")
+  @Test def testDuplicateLocals = shouldFail("DuplicateLocals")
+  @Test def testDuplicatMatchLocals1 = shouldFail("DuplicateMatchLocals1")
+  @Test def testDuplicatMatchLocals2 = shouldFail("DuplicateMatchLocals2")
+  @Test def testDuplicateModules = shouldFail(List("DuplicateModulesA", "DuplicateModulesB"))
+  @Test def testDuplicateParams = shouldFail("DuplicateParams")
+  @Test def testLocalScope = shouldFail("LocalScope")
+  @Test def testUndefinedConstructor1 = shouldFail("UndefinedConstructor1")
+  @Test def testUndefinedConstructor2 = shouldFail("UndefinedConstructor2")
+  @Test def testUndefinedFunction = shouldFail("UndefinedFunction")
+  @Test def testUndefinedModule = shouldFail("UndefinedModule")
+  @Test def testUndefinedTypeInModule = shouldFail(List("UndefinedTypeInModuleA", "UndefinedTypeInModuleB"))
+  @Test def testUndefinedType = shouldFail("UndefinedType")
+  @Test def testUndefinedVariable = shouldFail("UndefinedVariable")
+  @Test def testUnknownParent = shouldFail("UnknownParent")
+}

info/labs/lab04/test/scala/amyc/test/ParserTests.scala

+package amyc.test
+
+import amyc.utils._
+import amyc.ast._
+import amyc.parsing._
+import org.junit.Test
+
+class ParserTests extends TestSuite {
+
+  import NominalTreeModule.{Program => NP}
+
+  def treePrinterN(title: String): Pipeline[NP, Unit] = {
+    new Pipeline[NP, Unit] {
+      def run(ctx: Context)(v: NP) = {
+        println(title)
+        println(NominalPrinter(v))
+      }
+    }
+  }
+  val pipeline = AmyLexer.andThen(Parser).andThen(treePrinterN(""))
+
+  val baseDir = "parser"
+
+  val outputExt = "amy"
+
+  @Test def testLL1 = {
+    assert(Parser.program.isLL1)
+  }
+
+  
+  @Test def testEmpty = shouldOutput("Empty")
+
+  @Test def testErrorToken1 = shouldOutput("ErrorToken1")
+
+  @Test def testErrorToken2 = shouldOutput("ErrorToken2")
+
+  @Test def testLiterals = shouldOutput("Literals")
+
+  @Test def testPrecedence = shouldOutput("Precedence")
+
+  @Test def testAssoc = shouldOutput("Assoc")
+
+  @Test def testAssocSemicolon = shouldOutput("AssocSemicolon")
+
+  @Test def testFunDefs = shouldOutput("FunDefs")
+
+  @Test def testFunCalls = shouldOutput("FunCalls")
+
+  @Test def testClassDefs = shouldOutput("ClassDefs")
+
+  @Test def testPatterns = shouldOutput("Patterns")
+
+  @Test def testNestedMatch = shouldOutput("NestedMatch")
+
+  @Test def testParens = shouldOutput("Parens")
+
+  @Test def testQualifiedNames = shouldOutput("QualifiedNames")
+
+  @Test def testList = shouldOutput("List")
+
+  @Test def testIfCondition = shouldOutput("IfCondition")
+  @Test def testMatchScrutinee = shouldOutput("MatchScrutinee")
+  @Test def testChainedMatch = shouldOutput("ChainedMatch")
+
+  @Test def testArgsError1 = shouldFail("ArgsError1")
+  @Test def testArgsError2 = shouldFail("ArgsError2")
+  @Test def testClassDefError1 = shouldFail("ClassDefError1")
+  @Test def testClassDefError2 = shouldFail("ClassDefError2")
+  @Test def testClassDefError3 = shouldFail("ClassDefError3")
+  @Test def testClassDefError4 = shouldFail("ClassDefError4")
+  @Test def testCommentClosedTwice = shouldFail("CommentClosedTwice")
+  @Test def testEmptyFile = shouldFail("EmptyFile")
+  @Test def testFunDefError1 = shouldFail("FunDefError1")
+  @Test def testFunDefError2 = shouldFail("FunDefError2")
+  @Test def testFunDefError3 = shouldFail("FunDefError3")
+  @Test def testFunDefError4 = shouldFail("FunDefError4")
+  @Test def testFunDefError5 = shouldFail("FunDefError5")
+  @Test def testFunDefError6 = shouldFail("FunDefError6")
+  @Test def testIfPrecedence = shouldFail("IfPrecedence")
+  @Test def testIntError1 = shouldFail("IntError1")
+  @Test def testIntError2 = shouldFail("IntError2")
+  @Test def testIntError3 = shouldFail("IntError3")
+  @Test def testTypeWidth = shouldFail("TypeWidth")
+  @Test def testMatchAsOperand = shouldFail("MatchAsOperand")
+  @Test def testMissingOperand = shouldFail("MissingOperand")
+  @Test def testUnaryWithinUnary = shouldFail("UnaryWithinUnary")
+  @Test def testUnmatchedModule = shouldFail("UnmatchedModule")
+  @Test def testUnmatchedModuleName = shouldFail("UnmatchedModuleName")
+  @Test def testUnmatchedParen = shouldFail("UnmatchedParen")
+  @Test def testValAsOperand = shouldFail("ValAsOperand")
+  @Test def testValError = shouldFail("ValError")
+  @Test def testValInVal = shouldFail("ValInVal")
+  @Test def testWrongQName1 = shouldFail("WrongQName1")
+  @Test def testWrongQName2 = shouldFail("WrongQName2")
+  @Test def testWrongQName3 = shouldFail("WrongQName3")
+  @Test def testWrongQName4 = shouldFail("WrongQName4")
+
+}

info/labs/lab04/test/scala/amyc/test/TestSuite.scala

+package amyc.test
+
+import amyc.utils.Pipeline
+import java.io.File
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.StandardCopyOption
+
+abstract class TestSuite extends CompilerTest {
+  val pipeline: Pipeline[List[File], Unit]
+
+  val baseDir: String
+  lazy val effectiveBaseDir: String =
+    // getClass.getResource(s"/$baseDir").getPath
+    s"test/resources/$baseDir"
+
+  val passing = "passing"
+  val failing = "failing"
+  val outputs = "outputs"
+
+  val tmpDir = Files.createTempDirectory("amyc");
+
+  val outputExt: String
+
+  def getResourcePath(relativePath: String, otherPath: Option[String] = None): String =
+    val firstPath = Path.of(effectiveBaseDir, relativePath)
+
+    val (stream, path) = 
+      if Files.exists(firstPath) then
+        (Files.newInputStream(firstPath), relativePath)
+      else
+        otherPath match
+          case Some(p) =>
+            val secondPath = Path.of(effectiveBaseDir, p)
+            (Files.newInputStream(secondPath), p)
+          case None =>
+            assert(false, s"can not read $effectiveBaseDir/$relativePath")
+            (null, "")
+
+    val targetPath = tmpDir.resolve(path)
+    Files.createDirectories(targetPath.getParent())
+    Files.copy(stream, targetPath, StandardCopyOption.REPLACE_EXISTING)
+    targetPath.toAbsolutePath().toString()
+
+  def shouldOutput(inputFiles: List[String], outputFile: String, input: String = ""): Unit = {
+    compareOutputs(
+      pipeline,
+      inputFiles map (f => getResourcePath(s"$passing/$f.amy", Some(s"$passing/$f.grading.amy"))),
+      getResourcePath(s"$outputs/$outputFile.$outputExt", Some(s"$outputs/$outputFile.grading.$outputExt")),
+      input
+    )
+  }
+
+  def shouldOutput(inputFile: String): Unit = {
+    shouldOutput(List(inputFile), inputFile)
+  }
+
+  def shouldFail(inputFiles: List[String], input: String = ""): Unit = {
+    demandFailure(
+      pipeline,
+      inputFiles map (f => getResourcePath(s"$failing/$f.amy", Some(s"$failing/$f.grading.amy"))),
+      input
+    )
+  }
+
+  def shouldFail(inputFile: String): Unit = {
+    shouldFail(List(inputFile))
+  }
+
+  def shouldPass(inputFiles: List[String], input: String = ""): Unit = {
+    demandPass(pipeline, inputFiles map (f => getResourcePath(s"$passing/$f.amy", Some(s"$passing/$f.grading.amy"))), input)
+  }
+
+  def shouldPass(inputFile: String): Unit = {
+    shouldPass(List(inputFile))
+  }
+
+}

info/labs/lab04/test/scala/amyc/test/TestUtils.scala

+package amyc.test
+
+import java.io._
+
+/** Some utilities for running tests */
+trait TestUtils {
+  /** Run test,
+    * with input also redirected from a String,
+    * and output is redirected to a local StringBuilder.
+    */
+  def testWithRedirectedIO[T](test: => T, input: String): String = {
+    import scala.Console._
+    val inputS  = new StringReader(input)
+    val outputS = new ByteArrayOutputStream()
+    withOut(outputS) {
+      withErr(outputS) {
+        withIn(inputS) {
+          test
+        }
+      }
+    }
+    outputS.toString()
+  }
+}

info/labs/lab04/test/scala/amyc/test/TypeTests.scala

+package amyc.test
+
+import amyc.parsing._
+import amyc.ast.{Identifier, SymbolicPrinter}
+import amyc.ast.SymbolicTreeModule.Program
+import amyc.analyzer.{NameAnalyzer, TypeChecker}
+import amyc.utils._
+import org.junit.Test
+
+class TyperTests extends TestSuite {
+  // We need a unit pipeline
+  private def unit[A]: Pipeline[A, Unit] = {
+    new Pipeline[A, Unit] {
+      def run(ctx: Context)(v: A) = ()
+    }
+  }
+
+  val pipeline = AmyLexer.andThen(Parser).andThen(NameAnalyzer).andThen(TypeChecker).andThen(unit)
+
+  val baseDir = "typer"
+
+  val outputExt = "" // No output files for typechecking
+
+  @Test def testArithError1 = shouldFail("ArithError1")
+  @Test def testOperatorError1 = shouldFail("OperatorError1")
+  @Test def testConstructorError1 = shouldFail("ConstructorError1")
+  @Test def testFunctionCalls1 = shouldFail("FunctionCalls1")
+  @Test def testIfError1 = shouldFail("IfError1")
+  @Test def testLogicalError1 = shouldFail("LogicalError1")
+  @Test def testMatchError1 = shouldFail("MatchError1")
+  @Test def testSeqError1 = shouldFail("SeqError1")
+
+  @Test def testArithError2 = shouldFail("ArithError2")
+  @Test def testArithError3 = shouldFail("ArithError3")
+  @Test def testArithError4 = shouldFail("ArithError4")
+  @Test def testArithError5 = shouldFail("ArithError5")
+  @Test def testComparisonError = shouldFail("ComparisonError")
+  @Test def testOperatorError2 = shouldFail("OperatorError2")
+  @Test def testOperatorError3 = shouldFail("OperatorError3")
+  @Test def testConstructorError2 = shouldFail("ConstructorError2")
+  @Test def testConstructorError3 = shouldFail("ConstructorError3")
+  @Test def testConstructorError4 = shouldFail("ConstructorError4")
+  @Test def testEqualityError = shouldFail("EqualityError")
+  @Test def testFunctionCalls2 = shouldFail("FunctionCalls2")
+  @Test def testFunctionCalls3 = shouldFail("FunctionCalls3")
+  @Test def testIfAndErrorWrong = shouldFail("IfAndErrorWrong")
+  @Test def testIfError2 = shouldFail("IfError2")
+  @Test def testIfError3 = shouldFail("IfError3")
+  @Test def testLetError1 = shouldFail("LetError1")
+  @Test def testLetError2 = shouldFail("LetError2")
+  @Test def testLogicalError2 = shouldFail("LogicalError2")
+  @Test def testLogicalError3 = shouldFail("LogicalError3")
+  @Test def testMatchError2 = shouldFail("MatchError2")
+  @Test def testMatchError3 = shouldFail("MatchError3")
+  @Test def testMatchError4 = shouldFail("MatchError4")
+  @Test def testMatchError5 = shouldFail("MatchError5")
+  @Test def testMatchError6 = shouldFail("MatchError6")
+  @Test def testSeqError2 = shouldFail("SeqError2")
+  @Test def testSeqError3 = shouldFail("SeqError3")
+  @Test def testConcatError = shouldFail("ConcatError")
+  @Test def testErrorError = shouldFail("ErrorError")
+
+  @Test def testArithmetic = shouldPass("Arithmetic")
+  @Test def testComparison = shouldPass("Comparison")
+  @Test def testConstructors = shouldPass("Constructors")
+  @Test def testFunctionCalls = shouldPass("FunctionCalls")
+  @Test def testIf = shouldPass("If")
+  @Test def testIfWithError = shouldPass("IfWithError")
+  @Test def testLogical = shouldPass("Logical")
+  @Test def testMatch1 = shouldPass("Match1")
+  @Test def testMatch2 = shouldPass("Match2")
+  @Test def testMatch3 = shouldPass("Match3")
+  @Test def testMatchWithError = shouldPass("MatchWithError")
+  @Test def testMisc = shouldPass("Misc")
+  @Test def testSeq = shouldPass("Seq")
+  @Test def testSeqWithError = shouldPass("SeqWithError")
+  @Test def testLetWithError = shouldPass("LetWithError")
+  @Test def testError = shouldPass("Error")
+
+}

info/labs/lab05/amyc.sh

+#!/bin/bash
+# Script similar in structure to amytc.sh, see explanations there.
+if [ $# -eq 0 ]; then
+    echo "Usage: amyc Prog1.amy Prog2.amy ... ProgN.amy"
+    exit 1
+fi
+echo Compiling: $*
+AMYJAR=target/scala-3.5.2/amyc-assembly-1.7.jar
+if test -r "${AMYJAR}"; then
+    echo "Reusing existing jar: ${AMYJAR}"
+else
+    sbt assembly
+fi
+java -jar ${AMYJAR} library/Std.amy library/Option.amy library/List.amy $*
+echo Run wasmtime on one of the wasm files:
+ls wasmout/*.wasm

info/labs/lab05/amyi.sh

+#!/bin/bash
+# Script similar in structure to amytc.sh, see explanations there.
+if [ $# -eq 0 ]; then
+    echo "Usage: amyi Prog1.amy Prog2.amy ... ProgN.amy"
+    exit 1
+fi
+echo Intepreting: $*
+AMYJAR=target/scala-3.5.2/amyc-assembly-1.7.jar
+if test -r "${AMYJAR}"; then
+    echo "Reusing existing jar: ${AMYJAR}"
+else
+    sbt assembly
+fi
+java -jar ${AMYJAR} --interpret library/Std.amy library/Option.amy library/List.amy $*

info/labs/lab05/bin/LICENSE

+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.