Start work on pattern matching.

diff --git a/src/ofc/expression/TreeBuilder.scala b/src/ofc/expression/TreeBuilder.scala
index 6d177729bbae4343bbfe8a091c1037cead5b22c5..357c0755446f0f479ed6c2b3d3248a1ff6e3d137 100644 (file)
--- a/src/ofc/expression/TreeBuilder.scala
+++ b/src/ofc/expression/TreeBuilder.scala
@@ -11,8 +11,10 @@ class TreeBuilder(dictionary : Dictionary) {
 
     if (!lhsTree.isAssignable)
       throw new InvalidInputException("Non-assignable expression on LHS of assignment.")
-    else
-      new Assignment(lhsTree, rhsTree)
+    else (lhsTree, rhsTree) match {
+      case (lhs: ScalarExpression, rhs: ScalarExpression) => new Assignment(lhs, rhs)
+      case _ => throw new InvalidInputException("Assignment must be of scalar type.")
+    }
   }
   
   private def buildIndexedOperand(term: parser.IndexedIdentifier) : Expression = {

diff --git a/src/ofc/generators/Generator.scala b/src/ofc/generators/Generator.scala
index f5ee970a13da73e30b1026de241ce87f4ddb629f..e4b5639841d1902f74bf58a5ce67d71c0c66a74e 100644 (file)
--- a/src/ofc/generators/Generator.scala
+++ b/src/ofc/generators/Generator.scala
@@ -3,5 +3,5 @@ import ofc.parser.TargetAssignment
 import ofc.expression.{Dictionary,Assignment}
 
 trait Generator {
-  def acceptInput(dictionary: Dictionary, expression: Assignment, targetSpecific : Seq[TargetAssignment]) : Unit
+  def acceptInput(dictionary: Dictionary, expression: Assignment, targetSpecific : Seq[TargetAssignment])
 }

diff --git a/src/ofc/generators/Onetep.scala b/src/ofc/generators/Onetep.scala
index dc33598b376ca49ef98cdae8650aeee7153b4408..c2502b6c7142386553746257efd09caf89ec29bd 100644 (file)
--- a/src/ofc/generators/Onetep.scala
+++ b/src/ofc/generators/Onetep.scala
@@ -2,12 +2,24 @@ package ofc.generators
 
 import ofc.generators.onetep._
 import ofc.parser
-import ofc.expression.{Assignment,Dictionary}
+import ofc.expression.{Assignment,Expression,Dictionary}
 
 class Onetep extends Generator {
-  def acceptInput(dictionary: Dictionary, assignment: Assignment, targetSpecific : Seq[parser.TargetAssignment]) = {
+  def acceptInput(dictionary: Dictionary, assignment: Assignment, targetSpecific : Seq[parser.TargetAssignment]) {
     println(assignment)
+    if (matchLHS(assignment.lhs))
+      println("ha!")
   }
+
+  private def matchLHS(expression: Expression) : Boolean = {
+    import ofc.expression._
+
+    expression match {
+      case ScalarIndexingOperation(_: Matrix, List(bra, ket)) => true
+      case _ => false
+    }
+  }
+
   /*
 
   def buildMatrix(id: parser.Identifier, call : Option[parser.FunctionCall]) {