Pulled previous modification from master, merged ExampleTest.java

wyvernlang · Sep 15, 2019 · 3e87841 · 3e87841
2 parents 67eb542 + dbd5bf0
commit 3e87841
Show file tree

Hide file tree

Showing 46 changed files with 689 additions and 499 deletions.
diff --git a/.gitignore b/.gitignore
@@ -98,3 +98,4 @@ out.js
 */examples/*.js
 boot.js
 *.js.old
+out.gradver
diff --git a/.travis.yml b/.travis.yml
@@ -1,7 +1,8 @@
 # need to use sudo-enabled containers for additional RAM
+dist: trusty
 sudo: required
 language: java
-jdk: oraclejdk8
+jdk: oraclejdk9
 python:
   - "3.6"
 cache:
@@ -13,7 +14,7 @@ install:
   - cd ..
 before_script:
   - export WYVERN_HOME="$(pwd)"
-  - export _JAVA_OPTIONS="-Xmx6144m -Xms512m"
+  - export _JAVA_OPTIONS="-Xmx6144m -Xms512m -XX:+UseParallelGC"
 script:
   - cd tools
   - ant test

diff --git a/examples/AlexTalkDemos/07-WebTSL/main.wyv b/examples/AlexTalkDemos/07-WebTSL/main.wyv
@@ -2,16 +2,42 @@ require stdout
 
 import metadata html
 import metadata xml
+import metadata sql
 
-val h:html.HTMLExpr = ~
+val h : html.HTMLExpr = ~
   <html>
 
 stdout.print(h.eval() + "\n")
 
-val x:xml.XMLExpr = ~
+val x : xml.XMLExpr = ~
   <xml>
 
 stdout.print(x.eval() + "\n")
 
-// val hError:html.HTMLExpr = ~
+// val hError : html.HTMLExpr = ~
 //   <xml>
+
+val s1 : sql.SQLExpr = ~
+  UPDATE blah
+
+stdout.print("Evaluating s1.\n")
+s1.eval()
+
+val s2 : sql.SQLExpr = ~
+  INSERT blah
+
+stdout.print("Evaluating s2.\n")
+s2.eval()
+
+val s3 : sql.SQLExpr = ~
+  INSERT Something
+  UPDATE Anything
+
+stdout.print("Evaluating s3.\n")
+s3.eval()
+
+val s4 : sql.SQLExpr = ~
+  UPDATE Students SET GPA=3.0
+
+stdout.print("Evaluating s4.\n")
+s4.eval()
diff --git a/examples/AlexTalkDemos/07-WebTSL/sql.wyv b/examples/AlexTalkDemos/07-WebTSL/sql.wyv
@@ -1,3 +1,5 @@
+module sql
+
 import metadata wyvern.collections.list
 import wyvern.util.matching.regex
 import tsls.glexer
@@ -43,6 +45,7 @@ val tokens = new
 	val SET     :this.Kind = 37
 	val TABLE   :this.Kind = 38
 	val UPDATE  :this.Kind = 39
+
 	val VALUES  :this.Kind = 40
 	val WHERE   :this.Kind = 41
 
@@ -57,6 +60,7 @@ val lexer = glexer(tokens)
 // local bindings to make things easier
 type AST = ast.AST
 type Option = option.Option
+type None = option.None
 
 def createScanner(input:String):lexer.Scanner
     // Create a scanner configuration, setting up the whitespace operator
@@ -98,7 +102,7 @@ def createScanner(input:String):lexer.Scanner
 
 ////////////////////////////////////////////////////////////////////////////
 
-def debugOut(t:lexer.Token):Unit
+def debugOut(t : lexer.Token):Unit
     debug.printInt(t.kind())
     debug.print(": ")
     debug.print(t.print())
@@ -109,85 +113,135 @@ def lex(input:String):Unit
 
     // print the tokens, one at a time
     val t = scanner.nextToken()
-    debugOut(t)
-    debugOut(scanner.nextToken())
-    debugOut(scanner.nextToken())
-    debugOut(scanner.nextToken())
-    debugOut(scanner.nextToken())
-    debugOut(scanner.nextToken())
-    debugOut(scanner.nextToken())
-    debugOut(scanner.nextToken())
-    debugOut(scanner.nextToken())
-    debugOut(scanner.nextToken())
-    debugOut(scanner.nextToken())
-    debugOut(scanner.nextToken())
-
-/*  
-lex("UPDATE Students SET GPA=3.0 WHERE Name='John'")
-lex("SELECT AVG(GPA) FROM Students")
-lex("INSERT INTO Students VALUES ('John',4.0)")
-lex("CREATE TABLE Students (Name varchar(255), GPA float)")
-*/
+    printTokens(scanner, t)
 
-// A parse function for SQL queries
-def parse(input:String):Option[String]
-    val scanner = createScanner(input)
-    val t = scanner.nextToken()
-    match t:
-//        t:tokens.UPDATE => parseUpdate(scanner)
-//        t:tokens.SELECT => parseSelect(scanner)
-        t:tokens.INSERT => parseInsert(scanner)
-//        t:tokens.CREATE => parseCreate(scanner)
-        default => None[String]()
-
-def parseInsert(scanner:lexer.Scanner):Option[String]
-    val t = scanner.nextToken()
-    match t:
-        t:tokens.INTO => unit
-        default => error
-
-/*
-    // A parse function for reverse Polish notation
-def parse(input:String):option.Option[AST] // Option of AST
-	// create a scanner and scan the input
-	val scanner = lexer.makeScanner(config, input)
-	debug.print(input)
-	doParse(scanner)
-
-// The starting point for recursive-descent parsing	
-def doParse(scanner:lexer.Scanner):option.Option[AST]
-	val t = scanner.nextToken()
-	(t.kind() == tokens.NUMBER).ifTrue(
-	  () => parseWithOneExpr(scanner, ast.int(Int.from(t.print()))),
-	  () => option.None[AST]()
-	)
-
-// We've got exactly one expression on the stack
-def parseWithOneExpr(scanner:lexer.Scanner, exp:AST):option.Option[AST]
-	val t = scanner.nextToken()
-	(t.kind() == tokens.EOF).ifTrue(
-		() => option.Some[AST](exp),
-		() => (t.kind() == tokens.NUMBER).ifTrue(
-			() => parseWithTwoExprs(scanner, exp, ast.int(Int.from(t.print())), false),
-			() => option.None[AST]()
-		)
-	)
-
-// We've got two (ore more, if moreOnStack is true) expressions on the stack
-def parseWithTwoExprs(scanner:lexer.Scanner, exp1:AST, exp2:AST,
-                      moreOnStack:Boolean):option.Option[AST]
-	def compose(exp3:AST):option.Option[AST]
-		val expOption : option.Option[AST] = parseWithTwoExprs(scanner, exp2, exp3, true)
-		expOption.flatMap[AST]((expResult) => parseWithTwoExprs(scanner, exp1,expResult, moreOnStack))
-	val t = scanner.nextToken()
-	(t.kind() == tokens.OPERATOR).ifTrue(
-		() => moreOnStack.ifTrue(
-			() => option.Some[AST](ast.call(exp1,t.print(),{exp2})),
-		    () => parseWithOneExpr(scanner, ast.call(exp1,t.print(),{exp2}))
-		),
-		() => (t.kind() == tokens.NUMBER).ifTrue(
-			() => compose(ast.int(Int.from(t.print()))),
-			() => option.None[AST]()
-		)
-	)
-*/
+def printTokens(scanner : lexer.Scanner, token : lexer.Token) : Unit
+    debugOut(token)
+    val next = scanner.nextToken()
+    (next.kind() == tokens.EOF).ifTrue(
+       () => unit,
+       () => printTokens(scanner, next))
+
+// lex("UPDATE blah")
+// lex("UPDATE Students SET GPA=3.0 WHERE Name='John'")
+// lex("SELECT AVG(GPA) FROM Students")
+// lex("INSERT INTO Students VALUES ('John',4.0)")
+// lex("CREATE TABLE Students (Name varchar(255), GPA float)")
+
+////////////////////////////////////////////////////////////////////////////
+
+// SQLInsert ::= "INSERT" "IDENTIFIER"
+def parseInsert(scanner : lexer.Scanner, ctx : system.Context):Option[AST]
+  val token = scanner.nextToken()
+
+  if (token.kind() == tokens.EOF)
+      option.None[AST]() // need to have IDENTIFIER
+    else
+      if (token.kind() == tokens.IDENTIFIER)
+          val insert : AST = ast.parseExpression("sql.sql.insert(\"" + token.print() + "\")\n", ctx)
+          option.Some(insert)
+        else
+          option.None[AST]() // need to have IDENTIFIER
+
+// SQLInsert ::= "UPDATE" "IDENTIFIER"
+def parseUpdate(scanner : lexer.Scanner, ctx : system.Context):Option[AST]
+  val token = scanner.nextToken()
+
+  if (token.kind() == tokens.EOF)
+      option.None[AST]() // need to have IDENTIFIER
+    else
+      if (token.kind() == tokens.IDENTIFIER)
+          var next : lexer.Token = scanner.peekToken()
+          var updateWhat : String = token.print()
+          if (next.kind() == tokens.SET)
+              next = scanner.nextToken() // SET
+              next = scanner.nextToken()
+              if (next.kind() == tokens.IDENTIFIER)
+                  var setWhat : String = next.print()
+                  next = scanner.nextToken()
+                  if (next.kind() == tokens.EQUALS)
+                      next = scanner.nextToken()
+                      if (next.kind() == tokens.FLOAT_CONST)
+                          var value : String = next.print()
+                          val update : AST = ast.parseExpression("sql.sql.updateAndSet(\"" + updateWhat +
+                            "\", \"" + setWhat + "\", \"" + value + "\")\n", ctx)
+                          option.Some(update)
+                        else
+                          option.None[AST]() // need to have FLOAT after =
+                    else
+                      option.None[AST]() // need to have = after IDENTIFIER
+                else
+                  option.None[AST]() // need to have IDENTIFIER after SET
+            else
+              val update : AST = ast.parseExpression("sql.sql.update(\"" + token.print() + "\")\n", ctx)
+              option.Some(update)
+        else
+          option.None[AST]() // need to have IDENTIFIER
+
+// Parse until EOF.
+def parseAllSQLStatements(scanner : lexer.Scanner, ctx : system.Context, l : list.List[AST]) : list.List[AST]
+  val token = scanner.nextToken()
+  // debugOut(token)
+  var ast : option.Option[AST] = option.None[AST]()
+
+  if (token.kind() != tokens.EOF)
+      if (token.kind() == tokens.INSERT)
+          ast = parseInsert(scanner, ctx)
+        else
+          if (token.kind() == tokens.UPDATE)
+              ast = parseUpdate(scanner, ctx)
+            else
+              debug.print("SQL TSL ERROR: Undefined token encountered: " + token.print() + "\n")
+      if (ast.isDefined)
+        l.append(ast.get())
+      parseAllSQLStatements(scanner, ctx, l)
+    else
+      l
+
+// Convert expressions sequence to nested lets for lack of sequence.
+def astListToLet(l : list.List[AST]) : AST
+  if (l.length() == 0)
+      ast.parseExpressionNoContext("unit")
+    else
+      if (l.get(0).isDefined)
+          val e : AST = l.get(0).get()
+          l.remove(0)
+          ast.let("sequence", ast.types.unit(), e, astListToLet(l))
+        else
+          ast.parseExpressionNoContext("unit")
+
+////////////////////////////////////////////////////////////////////////////
+
+type SQL
+  def insert(id : String) : Unit
+  def update(id : String) : Unit
+  def updateAndSet(id : String, set : String, v : String) : Unit
+
+val sql : SQL = new
+  def insert(id : String) : Unit
+    debug.print("Running INSERT with argument: " + id + "\n")
+  def update(id : String) : Unit
+    debug.print("Running UPDATE with argument: " + id + "\n")
+  def updateAndSet(id : String, set : String, v : String) : Unit
+    debug.print("Running UPDATE with argument: " + id + " and setting " + set + " to value: " + v + "\n")
+
+type SQLExpr
+  def eval() : Unit
+
+  metadata new
+    // A parse function for SQL queries
+    // SQLStatement ::= SQLInsert | SQLUpdate
+    def parseTSL(input : String, ctx : system.Context) : option.Option[AST]
+      val scanner = createScanner(input)
+
+      var sqlStatements : list.List[AST] = list.make[AST]()
+      sqlStatements = parseAllSQLStatements(scanner, ctx, sqlStatements)
+
+      val defEval = ast.defDeclaration(
+        "eval",
+        list.make[ast.FormalArg](),
+        ast.types.unit(),
+        astListToLet(sqlStatements))
+      val declList : list.List[ast.Decl] = list.make[ast.Decl]()
+      declList.append(defEval)
+      option.Some(ast.object(declList))
diff --git a/examples/AlexTalkDemos/07-WebTSL/tsls/glexer.wyv b/examples/AlexTalkDemos/07-WebTSL/tsls/glexer.wyv
@@ -62,18 +62,23 @@ def makeScannerConfig(wsRX:regex.Regex):ScannerConfig = new (self)=>
 		// compute the resulting token
 		val resultOption : option.Option[ScanResult] = tokMatch.flatMap[ScanResult]((rkp:RegexpKindPair) =>
 			rkp.regex.findPrefixMatchOf(sWithoutWS).map[ScanResult]((m:regex.Match) =>
-				makeScanResult(m.matched(), rkp.kind, m.after()))
+				makeScanResult(m.matched(), rkp.kind, m.after())
+			)
 		)
 
 		// return the result, or error
 		resultOption.getOrElse(() => makeScanResult("ERROR",tokens.ERROR,""))
 
 resource type Scanner
 	def nextToken():Token
+	def peekToken():Token
 
 def makeScanner(config:ScannerConfig, s:String):Scanner = new
 	var current:String = s
 	def nextToken():Token
 		val result : ScanResult = config.getScanResult(this.current)
 		this.current = result.rest()
 		result.token()
+	def peekToken():Token
+		val result : ScanResult = config.getScanResult(this.current)
+		result.token()
diff --git a/examples/AlexTalkDemos/10-EditorCaps/logger.wyv b/examples/AlexTalkDemos/10-EditorCaps/logger.wyv
@@ -1,6 +1,6 @@
 module def logger(out : Stdout):Logger
 
-effect log = {system.ffiEffect}
+effect log = {system.FFI}
 
 def log(msg : String) : Unit
   out.print("LOG: " + msg + "\n")
diff --git a/examples/AlexTalkDemos/11-EditorEffects/polymorphicEffects/file.wyv b/examples/AlexTalkDemos/11-EditorEffects/polymorphicEffects/file.wyv
@@ -1,5 +1,5 @@
 module def file(java:Java) : polymorphicEffects.Resource
 
-effect wr = {system.ffiEffect}
+effect wr = {system.FFI}
 def write() : {wr} Unit
     unit
diff --git a/examples/AlexTalkDemos/11-EditorEffects/polymorphicEffects/network.wyv b/examples/AlexTalkDemos/11-EditorEffects/polymorphicEffects/network.wyv
@@ -1,5 +1,5 @@
 module def network(java:Java) : polymorphicEffects.Resource
 
-effect wr = {system.ffiEffect}
+effect wr = {system.FFI}
 def write() : {wr} Unit
     unit
diff --git a/examples/text-editor/JFrame.wyt b/examples/text-editor/JFrame.wyt
diff --git a/examples/text-editor/NativeUIManager.wyt b/examples/text-editor/NativeUIManager.wyt
@@ -4,4 +4,4 @@ type NativeUIManager
   def paintUIAttributeGray(element: String, attribute: String): Unit
   def paintUIAttributeLightGray(element: String, attribute: String): Unit
   def paintUIAttributeWhite(element: String, attribute: String): Unit
-  def updateLookAndFeel(jFrame: Dyn): Unit // FIX: Substitute Dyn with JFrame type. Currently gives an error.
+  def updateLookAndFeel(): Unit
diff --git a/examples/text-editor/plugins/darkTheme.wyv b/examples/text-editor/plugins/darkTheme.wyv
@@ -1,4 +1,4 @@
-module def darkTheme(logger: Logger, nativeUIManager: NativeUIManager, jFrame: JFrame): Plugin
+module def darkTheme(logger: Logger, nativeUIManager: NativeUIManager): Plugin
 // N.B.: In Java, once the theme is changed, apparently, there is no way to change it again, so this plugin shouldn't be registered in the menu.
 
 def getName(): String
@@ -13,5 +13,5 @@ def run(): Unit
   nativeUIManager.paintUIAttributeWhite("TextArea", "caretForeground")
   nativeUIManager.paintUIAttributeGray("ScrollPane", "background")
   nativeUIManager.paintUIAttributeDarkGray("ScrollBar", "background")
-  nativeUIManager.updateLookAndFeel(jFrame)
+  nativeUIManager.updateLookAndFeel()
   logger.updateLog("Set text editor theme to dark.\n")