Assignment 3 - Ellen Hui and Mauricio Molina (Team #5)

.gitignore

@@ -4,3 +4,4 @@ target
 .classpath
 .history
 .project
+*.swp

design.txt

@@ -1,16 +1,36 @@
 Who is the target for this design, e.g., are you assuming any knowledge on the
 part of the language users?
 
+	Beginner Programmers: Assuming they understand loops and states.
+
 Why did you choose this design, i.e., why did you think it would be a good idea
 for users to express the maze-searching computation using this syntax?
 
+	A bit more readable, but also still gets the same goal of teaching loops and states.
+	Same number of rules, just more organized and clear.
+
+
 What behaviors are easier to express in your design than in Picobot’s original
 design?  If there are no such behaviors, why not?
 
+        All of them are easier to express. The syntax alone makes it obvious
+        what each input means/does.
+
 What behaviors are more difficult to express in your design than in Picobot’s
 original design? If there are no such behaviors, why not?
 
+        Ideally, nothing would be more difficult. Same functionality in the end,
+        just more readable.
+
 On a scale of 1–10 (where 10 is “very different”), how different is your syntax
 from PicoBot’s original design?
 
+	4: For every line of picobot code, there exists an equivalent line of code for our
+	implementation, so it's not too different.
+
 Is there anything you don’t like about your design?
+
+	Makes the code more verbose. Overall file will be longer, doesn't add any
+	power to individual rules. You'd basically be writing Picobot code in this
+	implementation with syntactic sugar.
+

evaluation.txt

@@ -0,0 +1,57 @@
+Names: Ellen Hui and Mauricio Molina
+Date: September 28, 2014
+Domain Specific Languages
+Professor Ben
+
+
+
+
+
+- New syntax for defining picobot code
+
+	We decided to change the syntax for the inner declarations from
+
+    surroundedBy "NExx" then move "W" newState "confused"
+
+	and instead merge then move into thenDo, and also remove the newState keyword
+	(instead adding the new state argument into the thenDo call).  This also
+	necessitated adding parentheses, now that we have two arguments to thenDo, so w
+	figured we should give surroundedBy parentheses as well, for consistency.
+
+    surroundedBy("NExx") thenMove("W", "confused")
+
+	although not as clean and clear about what they're doing, it allows for a conditional structure rule creation. 
+
+	inState("StateName"){							if inState("StateName"){
+		surroundedBy("NExx") {								if(surroundedBy(Surroundings)){
+			thenMove("W", "confused")								thenMove(Direction, newState)
+		}													}
+	}	 											}
+
+
+
+	Originally started with a myState class that would hold all the information about a state
+	under our implementation and handle creation of rules defined by the user. However
+	we ended up finding scoping issues where we could not execute code in the way that we wanted. 
+	We attempted passing units of code through 3 methods to get it to our myClass constructor, but 
+	ended up losing that code while passing. The solution ended up being to get rid of the myState class entirely 
+	and simply mapped from string name to state.
+
+
+
+- Allowing user to user string names instead of requiring numbers
+
+	We mapped the string class names given by user to states using a map. While the user will use the state name they gave, 
+	we are still using number values to define states. It is hidden from the user. 
+
+
+- On a scale of 1-10, how much would you say you changed your syntax? 
+
+	We'd say we changed 3. The biggest changes were adding curly braces and parenthesis, and combining then and move into 
+	one keyword. 
+
+- On a scale of 1-10, how difficult was it to map your syntax to semantics? 
+
+	About a 6. Our biggest challenge was finding the correct architecture to hold and create rules. 
+	A big challenge was learning the limitations of scala. In the end, our solution ended up making 
+	our code more readable and easier to follow. 

grammar-actual.txt

@@ -0,0 +1,55 @@
+Names: Ellen Hui and Mauricio Molina
+Date: September 28, 2014
+Domain Specific Languages
+Professor Ben
+
+digit = "0" | nonzero_digit ;
+
+upper = "A" | "B" | "C" | "D" | "E" | "F" | "G"
+       | "H" | "I" | "J" | "K" | "L" | "M" | "N"
+       | "O" | "P" | "Q" | "R" | "S" | "T" | "U"
+       | "V" | "W" | "X" | "Y" | "Z" ;
+
+lower  = "a" | "b" | "c" | "d" | "e" | "f" | "g"
+       | "h" | "i" | "j" | "k" | "l" | "m" | "n"
+       | "o" | "p" | "q" | "r" | "s" | "t" | "u"
+       | "v" | "w" | "x" | "y" | "z" ;
+
+char = digit | upper | lower
+
+
+quote = '"' ;
+state = quote, char, {char}, quote ;
+
+
+(*
+    Each direction can be a wall, "x" for nothing there, or "*" for not there.
+    The full surroundings of the picobot is composed of all four directions.
+*)
+symbol = "x" | "*" ;
+north = "N" | symbol ;
+east = "E" | symbol ;
+west = "W" | symbol ;
+south = "S" | symbol ;
+surroundings = quote, north, east, west, south, quote ;
+
+(*
+    Direction to move in is one of NEWS or "X" for don't move.
+*)
+_move_direction = "N" | "E" | "W" | "S" | "X" ;
+move_direction = quote _move_direction quote ;
+
+semi = ";"
+
+(*
+    // what it would look like:
+
+    inState("goingWest") {
+      surroundedBy("N*x*") {thenMove("W", "goingWest")}
+      surroundedBy("x***") {thenMove("N", "goingNorth")}
+      surroundedBy("N*W*") {thenMove("X", "goingSouth")}
+    }
+*)
+case = "surroundedBy ", "(" , surroundings, ")",  "{" , thenMove ", "(" , moveDirection, " newState ", state, ")", "}", semi, "\n";
+rule = "inState ", "(" , state, ")",  {\n", case, {case}, "};"
+actual_grammar = {rule}

grammar-ideal.txt

@@ -0,0 +1,51 @@
+digit = "0" | nonzero_digit ;
+
+upper = "A" | "B" | "C" | "D" | "E" | "F" | "G"
+       | "H" | "I" | "J" | "K" | "L" | "M" | "N"
+       | "O" | "P" | "Q" | "R" | "S" | "T" | "U"
+       | "V" | "W" | "X" | "Y" | "Z" ;
+
+lower  = "a" | "b" | "c" | "d" | "e" | "f" | "g"
+       | "h" | "i" | "j" | "k" | "l" | "m" | "n"
+       | "o" | "p" | "q" | "r" | "s" | "t" | "u"
+       | "v" | "w" | "x" | "y" | "z" ;
+
+char = digit | upper | lower
+
+
+quote = '"' ;
+state = quote, char, {char}, quote ;
+
+
+(*
+    Each direction can be a wall, "x" for nothing there, or "*" for not there.
+    The full surroundings of the picobot is composed of all four directions.
+*)
+symbol = "x" | "*" ;
+north = "N" | symbol ;
+east = "E" | symbol ;
+west = "W" | symbol ;
+south = "S" | symbol ;
+surroundings = quote, north, east, west, south, quote ;
+
+(*
+    Direction to move in is one of NEWS or "X" for don't move.
+*)
+_move_direction = "N" | "E" | "W" | "S" | "X" ;
+move_direction = quote _move_direction quote ;
+
+semi = ";"
+
+(*
+    // what it would look like:
+
+    inState "stuckOnLeft" {
+        surroundedBy "NExx" then move "W" newState "confused" ;
+        surroundedBy "Nxxx" then move "W" newState "confused" ;
+        surroundedBy "xxxx" then move "W" newState "notConfused" ;
+    };
+
+*)
+case = "surroundedBy ", surroundings, " then move ", moveDirection, " newState ", state, semi, "\n";
+rule = "inState ", state, " {\n", case, {case}, "};"
+ideal_grammar = {rule}

grammar-orig.txt

@@ -0,0 +1,36 @@
+nonzero_digit = "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
+digit = "0" | nonzero_digit ;
+
+(*
+    State is can be two-digit (nonzero, can be zero) or single-digit (including
+    zero)
+*)
+state = nonzero_digit, digit | digit ;
+
+(*
+    Each direction can be a wall, "x" for nothing there, or "*" for not there.
+    The full surroundings of the picobot is composed of all four directions.
+*)
+symbol = "x" | "*" ;
+north = "N" | symbol ;
+east = "E" | symbol ;
+west = "W" | symbol ;
+south = "S" | symbol ;
+surroundings = north, east, west, south ;
+
+(*
+    Direction to move in is one of NEWS or "X" for don't move.
+*)
+move_direction = "N" | "E" | "W" | "S" | "X" ;
+
+(*
+    Parser uses space to separate pieces of the rule, so we need this.
+*)
+space = " " ;
+arrow = space, "->", space;
+
+(*
+    Compose everything!
+*)
+rule = state, space, surroundings, arrow, move_direction, space, state ;
+picobot_grammar = {rule} ;

src/main/scala/piconot/DSLImplementation.scala

@@ -0,0 +1,128 @@
+package piconot
+
+import java.io.File
+import picolib.maze.Maze
+import picolib.semantics.Anything
+import picolib.semantics.Blocked
+import picolib.semantics.East
+import picolib.semantics.GUIDisplay
+import picolib.semantics.MoveDirection
+import picolib.semantics.North
+import picolib.semantics.Open
+import picolib.semantics.Picobot
+import picolib.semantics.RelativeDescription
+import picolib.semantics.Rule
+import picolib.semantics.South
+import picolib.semantics.State
+import picolib.semantics.StayHere
+import picolib.semantics.Surroundings
+import picolib.semantics.TextDisplay
+import picolib.semantics.West
+import scalafx.application.JFXApp
+
+object DSLImplementation {
+  var globalRules:List[Rule] = List()
+
+  /**
+    *  Global number will keep track of the number of states there are
+    */
+  var numberOfStates = -1
+
+  var stringToStateMap: Map[String, State] = Map[String, State]()
+
+  // Make a Rule and add to list of global rules.  All arguments should already
+  // be converted into picolib.semantics objects.
+  def createRule(currentState: State,
+    surroundings: Surroundings,
+    direction: MoveDirection,
+    newState: State) {
+
+    globalRules = globalRules ::: List(Rule(currentState, surroundings, direction,
+      newState))
+  }
+
+  // Initial State
+  var currentState:State = new State("0");
+
+  // Increment global state number (must be unique State <-> number)
+  def nextStateNum():String = {
+    numberOfStates += 1
+    return numberOfStates.toString()
+  }
+
+  // Creates a new state from state name and rules
+  def inState(newState: =>  String)(rules: => Unit) {
+    // Check to see if we already made this state
+    if (stringToStateMap.contains(newState) )  {
+      currentState = stringToStateMap(newState)
+    } else {
+      currentState = State(nextStateNum)
+      stringToStateMap += newState -> currentState
+    }
+    // Parse rules for this state
+    rules
+  }
+
+  // Variables for rules to fill in
+  var surr: Surroundings = Surroundings(Anything, Anything, Anything, Anything)
+  var direc: MoveDirection = North
+  var nextS: State = State("0")
+
+  // Parse the surroundings
+  def surroundedBy(surroundings: String)(x: => Unit) = {
+
+    // Helper to map from chars to semantics.RelativeDescription
+    def charToSurr(x:Char):RelativeDescription = {
+      x match {
+        case close:Char if "NEWS".contains(close) => Blocked
+        case 'x' => Open
+        case '*' => Anything
+      }
+    }
+
+    // Make the Surroundings object
+    val tmp = surroundings.toList.map(y => charToSurr(y))
+    val semanticSurroundings = Surroundings(tmp(0), tmp(1), tmp(2), tmp(3))
+    surr = semanticSurroundings
+
+    // run the thenMove part, which sets direc and nextS
+    x
+    createRule(currentState, surr,direc,nextS)
+  }
+
+
+  // parse the destination state and direction
+  def thenMove(direction: String, newState: String) = {
+
+    // Helper to map from input move direction to semantics.MoveDirection
+    def strToMoveDir(x:String):MoveDirection = {
+      x match {
+        case "N" => North
+        case "E" => East
+        case "W" => West
+        case "S" => South
+        case "X" => StayHere
+      }
+    }
+
+    // Create new state as destination if necessary, set direc and nextS
+    if(stringToStateMap.contains(newState)) {
+      val nextState = stringToStateMap(newState)
+      val moveDir = strToMoveDir(direction)
+      direc = moveDir
+      nextS = nextState
+    } else {
+      val nextState = State(newState);
+      stringToStateMap += newState -> nextState
+      val moveDir = strToMoveDir(direction)
+      direc = moveDir
+      nextS = nextState
+
+    }
+  }
+
+  // return the rules
+  def getRules() = {
+    globalRules
+  }
+}