schaefer 0.0.3 → 0.0.4

data/Examples/Arithmatic/exampleDivision.sch

@@ -0,0 +1 @@
+(write (/ (/ 100 2) 2))

data/Examples/Arithmatic/exampleSubtraction.sch

@@ -0,0 +1 @@
+(write (- (- 100 (- 100 50) 25) 20))

data/Examples/Commenting/exampleComment.sch

@@ -0,0 +1,12 @@
+Commenting can be acheaved by simply typing outside of parenthesees. There 
+are a few things to be careful of though. Commas and some other symbols are
+not yet recognized in the parser so they return wierd values. This will be
+fixed in the next release. Also be careful not to include any parenthasees
+because otherwise they will be interpreted as commands!
+
+
+(define test
+  (function ()
+      (## When inside of parenthasees just use the double hash)
+      (write "hello")))
+(test)

data/Examples/FlowControl/exampleDo.sch

@@ -0,0 +1,18 @@
+Do is a function that steps through a list of commands. In some functions such as if as seen below
+a number of commands must be executed within a single set of parenthasees. This task is accomplished
+with the do function.																				 
+_____________________________________________________________________________________________________
+
+
+(define one 1)
+(define won 1)
+
+(if (equal? one won)
+  (do
+    (display "1 and 1 are equal")
+    (write " and thats a fact"))
+  (write "1 and 1 are not equal!"))
+
+
+-------------------------------------------------------------------------------------
+This example will return "1 and 1 are equal and thats a fact" followed by a new line.

data/Examples/FlowControl/exampleGreater.sch

@@ -0,0 +1,17 @@
+The isGreater? function allows you to test weather one number is greater than the other.
+The greater check takes two arguments and compares the first to the seccond.
+----------------------------------------------------------------------------------------
+
+
+(define one 1)
+(define two 2)
+
+(if(isGreater? one two)
+  (write "1 > 2")
+  (write "1 < 2"))
+
+
+
+-----------------------------------------------------------------------------------------------
+In this example the correct return is "1 < 2". Because 1 is being compared to 2 isGreater? will
+return false.

data/Examples/FlowControl/exampleIf.sch

@@ -0,0 +1,18 @@
+The if function takes three arguments. The first is the comparison which will either return
+true or false. The seccond is the true case which will be executed if the result of the 
+comparison is true. And the last is the false case which will be executed if the result
+of the comparisson is false.
+--------------------------------------------------------------------------------------------
+
+
+(define one 1)
+(define won 1)
+(define two 2)
+
+(if (= one won)
+  (write "1 = 1")
+  (write "1 != 1"))
+
+(if (equal? one two)
+  (write "1 = 2")
+  (write "1 != 2"))

data/Examples/FlowControl/exampleLesser.sch

@@ -0,0 +1,13 @@
+The isLesser? is a comparitive function that takes two arguments.
+TIf the first is lesser than the seccond the function will return
+true and if the first is greater than the seccond the function 
+will return false
+------------------------------------------------------------------
+
+
+(define one 1)
+(define two 2)
+
+(if(isLesser? one two)
+  (write "1 < 2")
+  (write "1 > 2"))

data/Examples/Functions/exampleFunction.sch

@@ -0,0 +1,18 @@
+The function function has many uses. When passed no variables it can be used
+to make your definition executable and allowing loops. In this example you
+are prompted to enter a password until you answer correctly. This demonstrates
+using empty functions to generate loops and executable definitions.
+-------------------------------------------------------------------------------
+
+
+(define program
+  (function ()
+    (display "Enter password (Hint its password): ")
+    (define response (input))
+    (if (= response "password")
+      (write "Great Job!")
+      (do
+        (write "Im sorry. Thats incorrect!")
+        (program)))))
+
+(program)

data/Examples/Functions/exampleFunction2.sch

@@ -0,0 +1,10 @@
+This example demonstrates how functions can be used by passing them arguments.
+Using functions in this mannor allows you to create new functions much like 
+some that define this language!
+------------------------------------------------------------------------------
+
+
+(define double
+  (function (x) (+ x x)))
+
+(write (double 5))

data/Examples/Input:Output/exampleDisplay.sch

@@ -0,0 +1,6 @@
+The display command takes one argument. The function then evaluates that argument and displays
+it to the screen without a trailing newline.
+----------------------------------------------------------------------------------------------
+
+
+(display "hello")

data/Examples/Input:Output/exampleInput.sch

@@ -0,0 +1,13 @@
+The input command takes no arguments. In allows for user input up until a newline
+is detected. The function then returns a string of the input excluding the newline
+character.
+----------------------------------------------------------------------------------
+
+
+(display "Enter password (Hint: its password): ")
+(define result (input))
+
+(if(= result "password")
+  (write "Excellent!")
+  (write "Wrong!"))
+

data/Examples/Input:Output/exampleWrite.sch

@@ -0,0 +1,6 @@
+The write command is nearly identical to the display command. It takes one argument then evaluates
+that argument and displays it to the screen with a trailing newline.
+--------------------------------------------------------------------------------------------------
+
+
+(write "hello")

data/Examples/Lists/exampleAppend.sch

@@ -0,0 +1,9 @@
+The append command takes an unlimited ammount of arguments. It works by constructing
+a single list given multiple in the same order that they are specified.
+------------------------------------------------------------------------------------ 
+
+
+(define l1 (quote (1 2 3 4 5)))
+(define l2 (quote (6 7 8 9 0)))
+
+(write (append l1 l2))

data/Examples/Lists/exampleConstruct.sch

@@ -0,0 +1,27 @@
+Construct takes two arguments. By performing a construct argument 1 is placed before argument 3
+and the result is not flattened. This has the effect of creating multi-dimensional arrays. Notice
+that the length reflects the number of elements with a sub-list contributing one.
+-------------------------------------------------------------------------------------------------
+
+
+(define list1 (list 1 2 3 4 5))
+(define list2 (list 6 7 8 9 0))
+
+(display "List1: ")
+(write list1)
+
+(display "List2: ")
+(write list2)
+
+(define ap (append list1 list2))
+(define con (construct list1 list2))
+
+(display "Appended List1-List2: ")
+(display ap)
+(display " -Length: ")
+(write (length ap))
+
+(display "Constructed List1-List2: ")
+(display con)
+(display " -Length: ")
+(write (length con))

data/Examples/Lists/exampleLength.sch

@@ -0,0 +1,9 @@
+The length function takes one argument. The argument is then evaluated
+and the length of the list is returned.
+----------------------------------------------------------------------
+
+
+(define l1 (list 0 1 2 3 4 5 6 7))
+(define l2 (list 8 9 10))
+
+(write (length (append l1 l2)))

data/Examples/Lists/exampleList.sch

@@ -0,0 +1,7 @@
+A list is a data type similar to an array in that it is a grouping of values
+but different in that they are not tied to any keys. When lists are created 
+with the list function each element is evaluated before it is stored.
+----------------------------------------------------------------------------
+
+
+(write (list 1 2 3 4 5))

data/Examples/Lists/exampleListFirst.sch

@@ -0,0 +1,10 @@
+The listFirst command takes one list as an argument. It then returns the first element
+of the provided list.
+--------------------------------------------------------------------------------------
+
+
+(define l1 (quote (1 2 3 4 5)))
+
+(write l1)
+(display "First: ")
+(write (listFirst l1))

data/Examples/Lists/exampleQuote.sch

@@ -0,0 +1,7 @@
+By using quote you can create lists without evaluating each element. When you create a list
+using the list keyword each element is evaluated and symbols are interpreted as variables.
+By quoting the contents of a list are not evaluated and symbols are left unevaluated.
+--------------------------------------------------------------------------------------------
+
+
+(write (quote (1 2 3 4 5 bob)))

data/Examples/Lists/exampleShift.sch

@@ -0,0 +1,11 @@
+The shift function takes one list as the argument. The function removes the first element from
+the list and returns the list again. A combination of listFirst and shift can be used to get
+a different values from a list.
+-----------------------------------------------------------------------------------------------
+
+
+(define l1 (list 1 2 3 4 5))
+(display "List: ")
+(write l1)
+(display "List Post-Shift: ")
+(write (shift l1))

data/Examples/Lists/exampleUnshift.sch

@@ -0,0 +1,18 @@
+The unshift function takes an unlimited number of arguments. The unshift function
+takes an array provided in argument 1 and evaluates the subsequent arguments. It
+then adds the result before the first list in the order they were provided and 
+then flattens the list. Eg. Argument 1 is the list 1 2 3. Argument 2 is the list
+3 4 5. Argument 3 is 5 6 7. The list resulting from unshifting under these conditions
+would be 3 4 5 5 6 7 1 2 3.
+-------------------------------------------------------------------------------------
+
+
+(define list1 (list -4 -3 -2 -1 0))
+(define list2 (list 1 2 3 4 5))
+(define list3 (list 6 7 8 9 10))
+
+(display "Append: ")
+(write (append list1 list2 list3))
+
+(display "Unshift: ")
+(write (unshift list3 list1 list2))

data/Examples/Practical/each.sch

@@ -0,0 +1,22 @@
+THe each example demonstrates how a typical array-each would be written in 
+SchaeferScript. Rather that just writing the element that you are currently
+at you could do any task.
+---------------------------------------------------------------------------
+
+
+(define i 0)
+(define offset 0)
+(define li (list 1 2 3 4 5 6))
+
+(define each
+  (function (lis)
+    (if (= (+ (length lis) offset) i)
+      (display "")
+      (do
+        (write (listFirst lis))
+        (define lis (shift lis))
+        (define i (+ i 1))
+        (define offset (+ offset 1))
+        (each lis)))))
+
+(each li)

data/Examples/Practical/fib.sch

@@ -0,0 +1,44 @@
+(define i 0)
+(define p 0)
+(define c 1)
+
+(define test
+  (function (x)
+    (if(= i x)
+      (do
+        (define i 0)
+        (define p 0)
+        (define c 1)
+      )
+      (do
+        (define np c)
+        (define nc (+ p c))
+        (define p np)
+        (define c nc)
+        (write c)
+        (define i (+ i 1))
+        (test x)
+      )
+    )
+  )
+)
+
+(define run
+  (function ()
+    (do
+      (write "How many Fibbonocci numbers would you like me to calculate?")
+      (display ">> ")
+      (define num (input))
+      (if (= num "exit")
+        (write "")
+        (do
+          (define num (->num num))
+          (test num)
+          (run)
+        )
+      )
+    )
+  )
+)
+
+(run)

data/lib/schaefer/Library/append.sch

@@ -0,0 +1,6 @@
+(define append
+  (native_function "
+    Proc.new() do |arguments, interpreter|
+      arguments.map {|x| interpreter.evaluate(x) }.flatten
+    end
+  "))

data/lib/schaefer/Library/comment.sch

@@ -0,0 +1,5 @@
+(define ## 
+  (native_function "
+    Proc.new do |arguments, interpreter|
+    end
+  "))

data/lib/schaefer/Library/construct.sch

@@ -0,0 +1,13 @@
+(define construct
+  (native_function "
+    Proc.new() do |arguments, interpreter|
+      arg_1 = interpreter.evaluate(arguments[0])
+      arg_2 = interpreter.evaluate(arguments[1]).dup
+      
+      if arg_2.is_a? Array
+        arg_2.unshift arg_1
+      else
+        [arg_1, arg_2]
+      end
+    end
+  "))

data/lib/schaefer/Library/display.sch

@@ -2,6 +2,6 @@
   (native_function "
     Proc.new do |arguments, interpreter|
       output = interpreter.evaluate(arguments[0])
-      print output
+      print interpreter.parser.toToken(output)
     end
   "))

data/lib/schaefer/Library/divisionOperator.sch

@@ -0,0 +1,7 @@
+(define /
+  (native_function "
+    Proc.new do |arguments, interpreter|
+      tmp = arguments.map {|x| interpreter.evaluate(x)}
+      tmp.inject {|sum, n| sum / n}
+    end
+  "))

data/lib/schaefer/Library/isgreater.sch

@@ -1,4 +1,4 @@
-(define isgreater?
+(define isGreater?
   (native_function "
     Proc.new do |arguments, interpreter|
       arguments.slice(1, arguments.length).all? do |x|
@@ -6,3 +6,5 @@
       end
     end
     "))
+
+(define > isGreater?)

data/lib/schaefer/Library/length.sch

@@ -0,0 +1,7 @@
+(define length
+  (native_function "
+    Proc.new do |argument, interpreter|
+      list = interpreter.evaluate(argument[0])
+      list.length
+    end
+  ")) 

data/lib/schaefer/Library/list.sch

@@ -0,0 +1,8 @@
+(define list
+  (native_function "
+    Proc.new do |arguments, interpreter|
+      arguments.map do |x|
+        interpreter.evaluate(x)
+      end
+    end
+  "))

data/lib/schaefer/Library/listFirst.sch

@@ -0,0 +1,7 @@
+(define listFirst
+  (native_function "
+    Proc.new do |argument, interpreter|
+      list = interpreter.evaluate(argument[0])
+      list[0]
+    end
+  "))

data/lib/schaefer/Library/quote.sch

@@ -0,0 +1,6 @@
+(define quote
+  (native_function "
+    Proc.new do |arguments, interpreter|
+      arguments[0]
+    end
+  "))

data/lib/schaefer/Library/shift.sch

@@ -0,0 +1,7 @@
+(define shift
+  (native_function "
+    Proc.new do |argument, interpreter|
+      list = interpreter.evaluate(argument[0])
+      list.slice(1, list.length)
+    end
+  "))

data/lib/schaefer/Library/subtractionOperator.sch

@@ -0,0 +1,7 @@
+(define -
+  (native_function "
+    Proc.new do |arguments, interpreter|
+      tmp = arguments.map {|x| interpreter.evaluate(x)}
+      tmp.inject {|sum, n| sum - n}
+    end
+  "))

data/lib/schaefer/Library/tonum.sch

@@ -0,0 +1,6 @@
+(define ->num 
+  (native_function "
+    Proc.new do |arguments, interpreter|
+      interpreter.evaluate(arguments[0]).to_i
+    end
+  "))

data/lib/schaefer/Library/tostr.sch

@@ -0,0 +1,6 @@
+(define ->str
+  (native_function "
+    Proc.new do |arguments, interpreter|
+      interpreter.evaluate(arguments[0]).to_s 
+    end
+  "))

data/lib/schaefer/Library/unshift.sch

@@ -0,0 +1,11 @@
+(define unshift
+  (native_function "
+    Proc.new do |arguments, interpreter|
+      arg1 = interpreter.evaluate(arguments[0])
+      newargs = arguments.slice(1, arguments.length)
+      newargs.reverse_each do |argument|
+        arg1.unshift(interpreter.evaluate(argument))
+      end
+      arg1.flatten
+    end
+  "))

data/lib/schaefer/Library/write.sch

@@ -2,6 +2,6 @@
   (native_function "
     Proc.new do |arguments, interpreter|
       output = interpreter.evaluate(arguments[0])
-      puts output
+      puts interpreter.parser.toToken(output)
     end
   "))

data/lib/schaefer/interpreter.rb

@@ -1,14 +1,15 @@
 module Schaefer
 	class Interpreter
-		attr_accessor :base_environment, :current_environment
+		attr_accessor :base_environment, :current_environment, :parser
 
 		def initialize()
 			@base_environment = @current_environment = Schaefer::Environment.new 
+      @parser = Parser.new
       loadLibrary
 		end
 
 		def run(program)
-			expressions = Parser.new.parse(program)
+ 			expressions = @parser.parse(program)
 			result = nil
 			expressions.each do |expression|
 				result = evaluate(expression)

data/lib/schaefer/parser.rb

@@ -12,10 +12,21 @@ class Parser
   end
   
   def tokenize(string) #method used split program into tokens by adding spaces arround '('s and calling string.split(' ')
-    string = string.gsub("(", " ( ")
-    string = string.gsub(")", " ) ")
-    tokens = string.split(" ")
-    return tokens
+    numOpen = string.count("(")
+    numClose = string.count(")")
+    numMissing = 0
+    if numOpen > numClose
+      numMissing = numOpen - numClose
+      raise RuntimeError, "#{numMissing} missing close parenthasees"
+    elsif numClose > numOpen
+      numMissing = numClose - numOpen
+      raise RuntimeError, "#{numMissing} extra close parenthasees"
+    elsif numClose == numOpen
+      string = string.gsub("(", " ( ")
+      string = string.gsub(")", " ) ")
+      tokens = string.split(" ")
+      return tokens
+    end
   end
   
   def replaceSLiterals(tokens, literals) #method used to restore string literals in our tokens array now that we dont have to worry about special cases
@@ -83,5 +94,49 @@ class Parser
     structure = formStructure(tokens)[1]
     return structure
   end
+
+  def convertLiterals(data)
+    return recursiveMap(data) do |x|
+      case x
+      when nil then []
+      when true then :"#t"
+      when false then :"#f"
+      else x
+      end
+    end
+  end
+      
+      # Convert a set of nested arrays back into an S-Expression
+  def toToken(data)
+    data = convertLiterals(data)
+    if(data.is_a?(Array))
+      mapped = data.map do |item|
+        if(item.is_a?(Array))
+          toToken(item)
+        else
+          item.to_s
+        end
+      end
+      "(" + mapped.join(" ") + ")"
+    else
+      data.to_s
+    end
+  end
+    
+  private
+  
+  def recursiveMap(data, &block)
+    if(data.is_a?(Array))
+      return data.map do |x|
+        if(x.is_a?(Array))
+          recursiveMap(x, &block)
+        else
+          block.call(x)
+        end
+      end
+    else
+      block.call(data)
+    end
+  end
 end
 

data/lib/schaefer/version.rb

@@ -1,3 +1,3 @@
 module Schaefer
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: schaefer
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: 
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Tommy Schaefer
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-05-27 00:00:00 Z
+date: 2012-05-29 00:00:00 Z
 dependencies: []
 
 description: Schaefer is a small programming language deigned to show how to build a programming language. Running the command 'schaefer' begins console based execution of code and passing a file name will execute the file. SchaeferScript is a scheme-style language where the core functions are written in ruby and other functions written in the language itself. You can access the source for SchaeferScript at https://github.com/tommyschaefer/SchaeferScript.
@@ -23,7 +23,7 @@ email:
 - me@tommyschaefer.net
 executables: 
 - .DS_Store
-- schaefer
+- schaefers
 extensions: []
 
 extra_rdoc_files: []
@@ -33,35 +33,47 @@ files:
 - .gitignore
 - .gitignore~
 - Examples/.DS_Store
-- Examples/exampleAdd.sch
-- Examples/exampleAdd.sch~
-- Examples/exampleDisplay.sch
-- Examples/exampleDisplay.sch~
-- Examples/exampleDo.sch
-- Examples/exampleDo.sch~
-- Examples/exampleFunction.sch
-- Examples/exampleFunction2.sch
-- Examples/exampleGets.sch
-- Examples/exampleGreater.sch
-- Examples/exampleIf.sch
-- Examples/exampleLesser.sch
-- Examples/exampleMultipy.sch
-- Examples/exampleWrite.sch
-- Examples/exampleWrite.sch~
+- Examples/Arithmatic/exampleAdd.sch
+- Examples/Arithmatic/exampleDivision.sch
+- Examples/Arithmatic/exampleMultipy.sch
+- Examples/Arithmatic/exampleSubtraction.sch
+- Examples/Commenting/exampleComment.sch
+- Examples/FlowControl/exampleDo.sch
+- Examples/FlowControl/exampleGreater.sch
+- Examples/FlowControl/exampleIf.sch
+- Examples/FlowControl/exampleLesser.sch
+- Examples/Functions/exampleFunction.sch
+- Examples/Functions/exampleFunction2.sch
+- Examples/Input:Output/exampleDisplay.sch
+- Examples/Input:Output/exampleInput.sch
+- Examples/Input:Output/exampleWrite.sch
+- Examples/Lists/exampleAppend.sch
+- Examples/Lists/exampleConstruct.sch
+- Examples/Lists/exampleLength.sch
+- Examples/Lists/exampleList.sch
+- Examples/Lists/exampleListFirst.sch
+- Examples/Lists/exampleQuote.sch
+- Examples/Lists/exampleShift.sch
+- Examples/Lists/exampleUnshift.sch
+- Examples/Practical/each.sch
+- Examples/Practical/fib.sch
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
 - bin/.DS_Store
-- bin/schaefer
+- bin/schaefers
 - lib/.DS_Store
 - lib/schaefer.rb
 - lib/schaefer/.DS_Store
 - lib/schaefer/.environment.rb.swp
 - lib/schaefer/Library/.DS_Store
 - lib/schaefer/Library/additionOperator.sch
+- lib/schaefer/Library/append.sch
+- lib/schaefer/Library/comment.sch
+- lib/schaefer/Library/construct.sch
 - lib/schaefer/Library/display.sch
-- lib/schaefer/Library/display.sch~
+- lib/schaefer/Library/divisionOperator.sch
 - lib/schaefer/Library/do.sch
 - lib/schaefer/Library/do.sch~
 - lib/schaefer/Library/equalTo.sch
@@ -72,13 +84,20 @@ files:
 - lib/schaefer/Library/input.sch
 - lib/schaefer/Library/isgreater.sch
 - lib/schaefer/Library/islesser.sch
+- lib/schaefer/Library/length.sch
+- lib/schaefer/Library/list.sch
+- lib/schaefer/Library/listFirst.sch
 - lib/schaefer/Library/multiplicationOperator.sch
+- lib/schaefer/Library/quote.sch
+- lib/schaefer/Library/shift.sch
+- lib/schaefer/Library/subtractionOperator.sch
+- lib/schaefer/Library/tonum.sch
+- lib/schaefer/Library/tostr.sch
+- lib/schaefer/Library/unshift.sch
 - lib/schaefer/Library/write.sch
-- lib/schaefer/Library/write.sch~
 - lib/schaefer/environment.rb
 - lib/schaefer/interpreter.rb
 - lib/schaefer/parser.rb
-- lib/schaefer/parser.rb~
 - lib/schaefer/version.rb
 - schaefer.gemspec
 homepage: https://github.com/tommyschaefer/SchaeferScript

data/Examples/exampleDisplay.sch

@@ -1 +0,0 @@
-(display "hello")

data/Examples/exampleDo.sch

@@ -1,8 +0,0 @@
-(define one 1)
-(define won 1)
-
-(if (equal? one won)
-  (do
-    (display "1 and 1 are equal")
-    (write " and thats a fact"))
-  (write "1 and 1 are not equal!")

data/Examples/exampleFunction.sch

@@ -1,11 +0,0 @@
-(define program
-  (function ()
-    (display "Enter password (Hint its password): ")
-    (define response (input))
-    (if (= response "password")
-      (write "Great Job!")
-      (do
-        (write "Im sorry. Thats incorrect!")
-        (program)))))
-
-(program)

data/Examples/exampleFunction2.sch

@@ -1,4 +0,0 @@
-(define double
-  (function (x) (+ x x)))
-
-(write (double 5))

data/Examples/exampleGets.sch

@@ -1,7 +0,0 @@
-(display "Enter password (Hint: its password): ")
-(define result (input))
-
-(if(= result "password")
-  (write "Excellent!")
-  (write "Wrong!")
-

data/Examples/exampleGreater.sch

@@ -1,7 +0,0 @@
-(define one 1)
-(define two 2)
-
-(if(isgreater? one two)
-  (write "1 > 2")
-  (write "1 < 2"))
-

data/Examples/exampleIf.sch

@@ -1,12 +0,0 @@
-(define one 1)
-(define won 1)
-(define two 2)
-
-(if (= one won)
-  (write "1 = 1")
-  (write "1 != 1"))
-
-(if (equal? one two)
-  (write "1 = 2")
-  (write "1 != 2"))
-

data/Examples/exampleLesser.sch

@@ -1,6 +0,0 @@
-(define one 1)
-(define two 2)
-
-(if(isLesser? one two)
-  (write "1 < 2")
-  (write "1 > 2"))

data/Examples/exampleWrite.sch

@@ -1 +0,0 @@
-(write "hello")