bakkdoor-blocktalk 0.1.1 → 0.1.2

data/LICENSE

@@ -0,0 +1,165 @@
+   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

data/README.markdown

@@ -0,0 +1,114 @@
+# ***Blocktalk*** #
+### **v0.1.2** ###
+
+## **Blocktalk** is a dynamic, object-oriented programming language somewhat in the tradition of Smalltalk and Ruby. ##
+
+It has a syntax familiar to Smalltalk users, but also integrates some syntactic elements from Ruby, 
+mainly most literal syntax including literal syntax for blocks, hashes, arrays, symbols and regular expressions.
+In contrast to Ruby, there are only very few predefined keywords in the language, everything else is achieved via
+methodcalls on objects, similar to how it is done in Smalltalk.
+
+
+### Class definitions ###
+
+For example, defining classes and modules in Blocktalk is also done via methodcalls to the Class and Module class
+respectively:
+
+    Class >> :Foo do
+	def bar = do |baz|
+	    Console puts: "In Foo#bar with baz = #{baz}"
+    	end
+    end
+
+Here, the ">>" method is called on the Class class (which also is an object - a class object), which takes the name
+of the class as a Symbol and then a codeblock that gets evaluated in the context of the class. This can be done in Ruby
+as well (in a similar way via `Class#new`, but in contrast to Ruby, this is the only way to do it.
+In Smalltalk you would do it in a similar way: `Superclass subclass: Foo`.
+
+
+### Codeblocks ###
+
+As in Ruby & Smalltalk, Blocktalk supports literal syntax for codeblocks (anonymous blocks of code / closures).
+In contrast to Ruby, there's is no conceptual difference between codeblocks passed to methods as part of a method call
+and storing them into variables - the syntax is the same. In Ruby you'd have to deal with converting blocks to Procs
+and vice versa.
+In constrast to Smalltalk, Blocktalk supports implicit passing of codeblocks to methods as it is done in Ruby. However,
+since the syntax for an implicit codeblock passed to a method and creating them explicitly (to be stored in a variable or
+or method argument, for example) is the same, you can also use the Smalltalk-ish approach of passing in codeblocks to
+methodcalls explicitly as arguments. 
+This is also used in a few predefined methods in the standard library. An example is the if_true:if_false method, that
+can take two explicit codeblocks for a if and then part, or just a block for the if part (either explicitly as an argument
+or implicitly as a ruby-like method call with a passed in block):
+
+    (a < b) if_true: {
+	Console print: "a smaller than b!"
+    } if_false: {
+	Console print: "a greater than b!"
+    }
+
+Since Blocktalk supports a very easy literal syntax for codeblocks, many special keywords aren't needed (as in Smalltalk).
+The example above shows, how a typicall if-then conditional could be written.
+
+Another example would be a while loop:
+
+    i = (Console gets: "Please enter a number!") to_i
+    {i < 10} while_true {
+	Console print: "a smaller than b!"
+	i = (Console gets: "Enter again!") to_i
+    }
+
+In this case, while_true takes a ruby-like implicit block, noticeable by the absence of the colon after the methodname,
+which indicates a method call with a passed in argument.
+
+
+### Exception Handling ###
+
+Exception handling in Blocktalk is done similar to most programming languages, including Ruby:
+
+
+    i = Console gets: "Please enter a number!"
+    try {
+	Console print: "10 / i = #{(10 / (i to_i))}"
+   
+	catch: ZeroDivisionError do |ex|
+	    Console print: "got a exception: #{ex message}"
+	end
+
+	ensure {
+	    Console print: "this will get done, no matter what value i has!"
+	}
+    }
+
+This example will obviously fail if the we enter a zero. As in Ruby, the ensure-block gets run independent of an error
+being raised or not (similar to e.g. `finally` in Java). 
+
+
+### Other features ###
+
+As Blocktalk is still in heavy development, new features may be added or old ones redesigned - I'm very open to discussion
+if anyone has some cool ideas, just let me know.
+
+
+## Current status ##
+
+I have most of the basic features done, Including Class & Module definitions (with class & instance methods etc), most
+literal syntax (Integers, Floats, Symbols, Hashes, Arrays, Codeblocks, Regular Expressions ...) and a *working* interpreter
+written in Ruby, that actually is somewhat of a compiler. As of now, the code gets parsed and translated into (quite ugly)
+Ruby code, which then gets fed into Ruby and executed. I know this isn't the best way for now probably, but it works.
+Something I'd like to add in the future is a bytecode compiler for Ruby 1.9.
+
+
+## Implementation ##
+
+Blocktalk is implemented in Ruby. The goal is to be able to run any Ruby code available, making it easy to get something
+real and working fast.
+Another goal is to add some more unique features, that Ruby for example does not support. I'm very open for ideas on this.
+
+
+## Dependencies ##
+
+- Treetop ([http://treetop.rubyforge.org](http://treetop.rubyforge.org)) for the parser.
+
+- That's it for now :)
+
+#### (C) 2009 Christopher Bertels / [http://www.adztec-independent.de](http://www.adztec-independent.de) ####

data/TODO

@@ -0,0 +1,9 @@
+##################
+# TODO for v0.1: #
+##################
+
+- add optimizations, when possible
+- add more documentation & enhance standard library (as much as possible in Blocktalk itself)
+
+ideas: 
+------

data/benchmark.bt

@@ -0,0 +1,18 @@
+#!/usr/bin/env blocktalk
+
+# simple benchmarking script.
+# runs a given blocktalk programm a specified amount of times (default 10).
+
+amount = 10
+args = ARGV join: " "
+
+(args =~ /-n ([0-9]+)/) if {
+  amount = $1 to_i
+}
+
+script_file = ARGV at: 0
+
+amount times do |i|
+  Kernel system: "blocktalk #{script_file} > /dev/null"
+  Console print: "."
+end

data/evaluator.rb

@@ -0,0 +1,19 @@
+class Evaluator
+  @load_path = File.dirname(__FILE__)
+  @expressions = ["require \"#{@load_path}/lib/core\""]
+
+  def self.add(code_str)
+    unless code_str.nil? or code_str.empty?
+      @expressions << code_str
+    end
+  end
+
+  def self.eval(argv = [])
+#    Kernel::eval @expressions.join(";")
+    system("/usr/bin/env ruby -e '#{@expressions.join(';')}' #{argv.join(' ')}")
+  end
+
+  def self.inspect
+    Kernel::puts @expressions.join("\n")
+  end
+end

data/examples/chained_method_call.bt

@@ -0,0 +1,15 @@
+require: "lib/blocktalk/string"
+
+str = "hello, world"
+str2 = str upcase substitute: "," with: "::" downcase substitute: " " with: "--"
+Console puts: str2
+
+10 < 5 if_true {
+  Console puts: "yoo"
+} if_false {
+  Console puts: "noo"
+}
+
+(1 < 4) if_true {
+  Console puts: "1 < 4"
+}

data/examples/classes_modules.bt

@@ -0,0 +1,68 @@
+Module >> :ModuleA do
+  def method_a = do
+    Console puts: "in ModuleA#method_a!"
+  end
+end
+
+
+Module >> :ModuleB do
+  def method_b = do
+    Console puts: "in ModuleB#method_b!"
+  end
+
+  def method_c = do |param and: param2 plus: param3|
+    Console puts: "in ModuleB#method_c: #{param}, #{param2}, #{param3}"
+  end
+end
+
+Class >> :Place do
+  def self from_city = do |city_name|
+    # should do something useful here ...
+    Place new
+  end
+
+  def coordinates = do
+    # do some calculation here...
+    return (Kernel rand)
+  end
+end
+
+Class >> :Person {
+  self mixin: [ModuleA, ModuleB]
+  def initialize = do |name age: age city: city|
+    @name = name
+    @age = age
+    @city = city
+  end
+
+  def go_to = do |place with: vehicle|
+    ((place is_a?: Place) and: ((self distance_to: place) < 10.5)) if_true {
+      vehicle take: self to: place
+    }
+  end
+
+  def place = do
+    Place from_city: @city
+  end
+
+  def distance_to = do |place|
+    (place is_a?: Place) if_true: {
+      dist = ((self place) coordinates) - (place coordinates)
+      dist abs
+    } if_false: {
+      0.0
+    }
+  end
+}
+
+
+chris = Person new: "Christopher Bertels" age: 22 city: "Osnabrück"
+city = Place from_city: "Berlin"
+
+Console puts: "Distance from chris to city:"
+Console puts: (chris distance_to: city)
+
+# Person mixed in ModuleA & ModuleB:
+chris method_a
+chris method_b
+chris method_c: "hey" and: "ho" plus: "cool!"

data/examples/exceptions.bt

@@ -0,0 +1,28 @@
+try{
+  0 / 0
+  catch: ZeroDivisionError do |ex|
+    Console puts: "in catching Error!"
+    Console puts: "something else ;)"
+  end
+
+  ensure {
+    Console puts: "error!"
+  }
+}
+
+# lets raise an exception ourselves
+
+Class >> {:WeirdError => StandardError} do
+  def initialize = do |error_message|
+    super: error_message
+  end
+end
+
+try{
+  Console puts: "gonna raise an exception!"
+  Error raise: (WeirdError new: "catch me if you can!")
+
+  catch: WeirdError do |ex|
+    Console puts: "exception caught: #{ex.inspect}"
+  end
+}

data/examples/fac.bt

@@ -0,0 +1,23 @@
+Fixnum class_eval do
+  def fac_slow = do
+    (self == 1) if_true: {
+      1
+    } if_false: {
+      (self * ((self - 1) fac_slow))
+    }
+  end
+
+  def fac_fast = do
+    val = self
+    acc = val
+    {val > 1} while_true {
+      val = val - 1
+      acc = acc * val
+    }
+    return acc
+  end
+end
+
+Console puts: (289 fac_slow)
+Console puts
+Console puts: (289 fac_fast)

data/examples/inline_ruby.bt

@@ -0,0 +1,20 @@
+# inline ruby test
+Class >> :Foo do
+  %ruby{
+    # some inline ruby code ;)
+    puts "this gets run, when this classdefinition gets executed!"
+    puts "we can put any kind of ruby code here :)"
+    def ruby_method(arg)
+      puts "in Foo#ruby_method: #{arg}"
+    end
+  }%
+
+  def blocktalk_method = do
+    Console puts: "in Foo#blocktalk_method!"
+    Console puts: "calling Foo#ruby_method:"
+    self ruby_method: "chris"
+  end
+end
+
+f = Foo new
+f blocktalk_method

data/examples/linecounter.bt

@@ -0,0 +1,8 @@
+((ARGV size) > 0) if_true: {
+  filename = ARGV at: 0
+  File open: filename do |f|
+    Console puts: "#{filename} has #{f.readlines.size} lines!"
+  end
+} if_false: {
+  Console puts: "Please specify a file to count lines on!"
+}

data/examples/multiple_methodcall.bt

@@ -0,0 +1 @@
+Console puts: :cool; print: "hello\n"

data/examples/portscan.bt

@@ -0,0 +1,39 @@
+System require: "socket"
+
+host = "localhost"
+
+(ARGV at: 0) if {
+  host = (ARGV at: 0)
+}
+
+max_port = 1024
+
+((ARGV join: " ") =~ /\-n ([0-9]+)/) if {
+  max_port = $1 to_i
+}
+
+open_ports = []
+
+1 upto: max_port do |port|
+  Thread new {
+    try{
+      t = TCPSocket new: host port: port
+      open_ports << port
+
+      s = Socket getnameinfo: ["AF_INET", port, host]
+      Console puts: ("\nPort #{port} (#{s[1]})" + " is open.")
+
+      catch{
+        Console print: "."
+      }
+
+      ensure{
+        t if { t close }
+      }
+    }
+  }
+end
+
+Console puts
+Console puts: "Open ports on #{host} are:"
+Console puts: (open_ports join: ", ")

data/examples/require.bt

@@ -0,0 +1,8 @@
+# requiring Ruby code & libraries works like this:
+System require: "socket"
+
+# requiring Blocktalk code like this:
+require: "examples/exceptions.bt"
+
+Console puts: "back in require.bt"
+

data/examples/ruby_methods.bt

@@ -0,0 +1,20 @@
+# calling some ruby methods...
+
+File open: "examples/test3.bt" mode: "r" do |f|
+  (f readlines) each do |l|
+    Console puts: l
+  end
+end
+
+# and again, this time cached!
+File open: "examples/test3.bt" mode: "r" do |f|
+  (f readlines) each do |l|
+    Console puts: l
+  end
+end
+
+
+str = "hello, world, how are you?"
+str2 = str gsub: "," with: "!"
+Console puts: str;
+        puts: str2

data/examples/string_interpol.bt

@@ -0,0 +1,10 @@
+greeted = "world!"
+Console puts: "Hello, #{greeted}"
+
+x = 0
+{(x to_i) <= 0} while_true {
+  x = Console gets: "Please enter a positive number (> 0):"
+}
+
+Console puts: "entered number is: #{x}"
+Console puts: "number (#{x to_i}) < 10: #{(x to_i) < 10}"

data/examples/string_test.bt

@@ -0,0 +1,13 @@
+# Extend String class with ends_with? method
+# that checks if a string ends with a given string.
+String extend {
+  def ends_with? = do |end_string|
+    start_index = -1 * (end_string length)
+    end_index = end_string length
+    tail = self range_from: start_index to: end_index
+    tail == end_string
+  end
+}
+
+Console puts: ("hello, world!" ends_with?: "world!")    # output: true
+Console puts: ("hello, world!" ends_with?: "world")     # output: false

data/examples/test.bt

@@ -0,0 +1,45 @@
+# this is just for demonstration
+# there probably won't be the need to require the console module from the
+# standard library every time you want to print something to the screen ;)
+System require: "console"
+
+# we support ruby-style blocks with do ... end and curly braces { ... }
+File open: "test.txt" mode: "w" do |f|
+  f puts: "what's up, dog?!"
+  f puts: "crazy shit, yo!"
+  f puts: "hahaha!!"
+end
+
+10 to: 0 do |i|
+  Console puts: i
+end
+
+i = 0
+(i < 10) while_true: do |i|
+  Console puts: i
+  i incr
+end
+
+numbers = [1,2,3,4,5] select: {|i| i < 3}
+numbers each: do |i|
+  puts i
+end
+
+(1 .. 100) each: {|i| Console puts: i}
+
+squares = (1 .. 100) collect: {|i| i * i}
+
+
+# define a square method
+square = { |x|
+  x * x
+}
+
+# or like this:
+abs = { |num|
+  (num > 0) if_true {
+    return num
+  }
+
+  num * -1
+}