Work on parsing declarations.

diff --git a/build.xml b/build.xml
index 3fdc8976f98b7a5092fd32469694036cbb1aff0c..a1cac7bbc8ad8c1e16546ab696722352a1aff601 100644 (file)
--- a/build.xml
+++ b/build.xml
@@ -40,6 +40,7 @@
       destdir="${build.dir}" 
       force="false"
       deprecation="yes"
+      unchecked="yes"
     >
       <include name="**/*.scala"/>
     </scalac>

diff --git a/src/ofc/OFC.scala b/src/ofc/OFC.scala
index 5289ecd5e270a5cc065727362a7bbfc9fed311fa..8f22440eea51f1ac4acd4ad383179f31cd07bf17 100644 (file)
--- a/src/ofc/OFC.scala
+++ b/src/ofc/OFC.scala
@@ -1,6 +1,10 @@
 package ofc
+
 import java.io.FileReader
-import parser.{Parser,Statement,ParseException}
+import parser.{Parser,Statement,Target,Identifier,ParseException}
+import generators.Generator
+
+class InvalidInputException(s: String) extends Exception(s)
 
 object OFC extends Parser {
 
@@ -20,10 +24,25 @@ object OFC extends Parser {
         Console.err.println("Parse failure: "+e)
         System.exit(1)
       }
+      case e: InvalidInputException => {
+        Console.err.println("Semantic Error: "+e)
+        System.exit(1)
+      }
     } finally {
       reader.close
     }
   }
 
-  def processAST(statements : List[Statement]) = print(statements.mkString("\n") + "\n")
+  def processAST(statements : List[Statement]) = {
+    val targetStatements = 
+      statements.filter(_ match { case _ : Target => true; case _ => false }).asInstanceOf[List[Target]]
+
+    val generator : Generator = targetStatements match {
+      case List(Target(Identifier("ONETEP"))) => new generators.Onetep
+      case List(Target(Identifier(x))) => throw new InvalidInputException("Unknown target: " + x)
+      case _ => throw new InvalidInputException("OFL file should have single target statement.")
+    }
+
+    generator.acceptInput(statements)
+  }
 }

diff --git a/src/ofc/parser/Statement.scala b/src/ofc/parser/Statement.scala
index f09c33b7dc5468eba59311e7c2114d4e3e93fdfb..01a1fbbc2f725c780990ebfa803c7cc29aff4a49 100644 (file)
--- a/src/ofc/parser/Statement.scala
+++ b/src/ofc/parser/Statement.scala
@@ -1,6 +1,6 @@
 package ofc.parser
 
-class Identifier(name: String) {
+case class Identifier(name: String) {
   override def toString : String = "id(\""+name+"\")"
 }
 
@@ -8,60 +8,60 @@ sealed abstract class Statement
 class Comment(value: String) extends Statement {
   override def toString : String = "comment(\""+value+"\")"
 }
-class DeclarationList(oflType: OFLType, names: List[Identifier]) extends Statement {
+case class DeclarationList(oflType: OFLType, names: List[Identifier]) extends Statement {
   override def toString : String = "decl("+oflType+", "+names+")"
 }
-class Definition(term: IndexedTerm, expr: Expression) extends Statement {
+case class Definition(term: IndexedTerm, expr: Expression) extends Statement {
   override def toString : String = "define("+term+", "+expr+")"
 }
-class Target(name: Identifier) extends Statement {
+case class Target(name: Identifier) extends Statement {
   override def toString : String = "target("+name+")"
 }
-class TargetAssignment(id: Identifier, value: FunctionCall) extends Statement {
+case class TargetAssignment(id: Identifier, value: FunctionCall) extends Statement {
   override def toString : String = "target_assignment("+id+", "+value+")"
 }
 
 sealed abstract class OFLType
-class Matrix extends OFLType {
+case class Matrix() extends OFLType {
   override def toString : String = "Matrix"
 }
-class FunctionSet extends OFLType {
+case class FunctionSet() extends OFLType {
   override def toString : String = "FunctionSet"
 }
-class Index extends OFLType {
+case class Index() extends OFLType {
   override def toString : String = "Index"
 }
 
 sealed abstract class Expression
-class ScalarConstant(s: Double) extends Expression {
+case class ScalarConstant(s: Double) extends Expression {
   override def toString : String = s.toString
 }
-class IndexedTerm(id: Identifier, indices : List[Identifier]) extends Expression {
-  override def toString : String = id+"["+indices.mkString(",")+"]"
+case class IndexedTerm(id: Identifier, indices : List[Identifier]) extends Expression {
+  override def toString : String = id+indices.mkString("[", ", ", "]")
 }
-class Operator(id: Identifier, operands : List[Expression]) extends Expression {
-  override def toString : String = "operator("+id+ ", ["+ operands.mkString(",")+"])"
+case class Operator(id: Identifier, operands : List[Expression]) extends Expression {
+  override def toString : String = "operator("+id+ ", " + operands.mkString("[", ", ", "]")+")"
 }
 
 sealed abstract class ScalarOperation extends Expression
-class Multiplication(a: Expression, b: Expression) extends ScalarOperation {
+case class Multiplication(a: Expression, b: Expression) extends ScalarOperation {
   override def toString : String = "mul("+a.toString+","+b.toString+")"
 }
-class Division(a: Expression, b: Expression) extends ScalarOperation {
+case class Division(a: Expression, b: Expression) extends ScalarOperation {
   override def toString : String = "div("+a.toString+","+b.toString+")"
 }
 
-class FunctionCall(name: Identifier, params: ParameterList) {
+case class FunctionCall(name: Identifier, params: ParameterList) {
   override def toString : String = "call("+name+", "+params+")"
 }
 
 sealed abstract class Parameter
-class ParameterList(params: List[Parameter]) extends Parameter {
-  override def toString : String = "["+params.mkString(",")+"]"
+case class ParameterList(params: List[Parameter]) extends Parameter {
+  override def toString : String = params.mkString("[", ", ", "]")
 }
-class StringParameter(s: String)  extends Parameter {
+case class StringParameter(s: String)  extends Parameter {
   override def toString : String = "\""+s+"\""
 }
-class NumericParameter(s: Double)  extends Parameter {
+case class NumericParameter(s: Double)  extends Parameter {
   override def toString : String = s.toString
 }