bakkdoor-blocktalk 0.1.1 → 0.1.2

data/language-spec/blocktalk-lang-spec.bt

@@ -0,0 +1,232 @@
+# 'blocktalk' language specification
+# comments work like this
+# or like this:
+
+#-#
+  multiline comments look like this
+#-#
+
+# simple anonymous function definition.
+# functions / procedures / methods in general are simply names
+# to which anonymous methods / codeblocks are bound.
+# in contrast to ruby, there is no difference between lambdas, procs & blocks.
+foo = do |bar baz|
+  bar puts # sending message puts to object bar
+end
+
+# square is a function, that takes one argument (x)
+# and returns the square of it.
+# note: as in ruby, message is a expression-based language,
+# so no explicit return statement is needed.
+# the last expression gets returned implicitly.
+square = do |x|
+  x * x
+end
+
+
+# creating a subclass of Object called Integer.
+# if no super class specified to constructor, Object is taken.
+Class in: Integer do
+  # include Numerical module (as in ruby):
+  include Numerical
+
+  # operators are simply methods / messages that a class can define however it wants.
+  # in this case, the * operator is defined to be a message with one parameter (y).
+  def * = do |y|
+
+    # |> is a special operator that allows the last expression in a line above this one to be used
+    # as the argument to a method call.
+    # this makes it easier to handle several methodcalls to an object, retrieved in a more complex expression
+    # without needing to save it to a local variable or whatever.
+
+    (y is_a?: Number)
+    |> if_true do
+      # this gets executed, if the upper condition (boolean) object is true
+      (y is_a?: Integer) if_true do
+        Math base_int_mult: self with: y # some base function defined in the vm or whatever (in this case in the Math module)
+      end
+
+      (y is_a?: Float) if_true do
+        Math base_float_mult: self with: y
+      end
+    end
+
+    |> if_false do
+      # raise an exception:
+      Error raise: (WrongArgumentError new: "Expected a number, but got #{y class}")
+    end
+
+  end
+end
+
+
+Class in: File deriving: Stream do
+  # constructor that takes a file handle given by the operating system or so.
+  def new = do |file_handle|
+    File new: (file_handle file_name) mode: (file_handle access_mode)
+  end
+
+  # constructor to File class
+  def new = do |file_name mode|
+    @file_name = file_name
+    @access_mode = mode
+
+    block_given?
+    |> if_true do
+      File open: file_name mode: mode do |f|
+        yield f
+      end
+    end
+  end
+
+  # class method with named parameter.
+  # gets calles like this:
+  # File open "foo.txt" with:"r" do |f|
+  #   Console puts : f readlines
+  # end
+  self open = do |file_name mode=nil|
+    mode ||= "r"
+    block_given? if_true do
+      # trying method takes a block (between { and }).
+      # this would also work: trying do ... end (same as in ruby).
+      # in ruby: trying = begin.
+      try {
+        # open file etc.
+        file = File new: (IO base_file_open: file_name mode)
+        # yield to block
+        yield: [file]
+
+        # catching errors is easy.
+        # simply use catch method with a given block to execute
+        # if the specified class (as the parameter) is caugth.
+        catch: IOError do |ex|
+          Console puts: "Error while trying to open file #{file_name} with access mode: #{mode}"
+        end
+
+        # Error is baseclass of all exceptions -> this will get called when all the others didn't match
+        catch: Error do |ex|
+          Console puts: "Error: #{ex}"
+        end
+
+        # blocks to methodcalls can also be done via curly-braces syntax {} (instead of do ... end)
+        ensure {
+          file close # always close the file
+        }
+      }
+      # and finally close again
+    end
+  end
+
+  # ... more methods for File class go here ...
+end
+
+
+
+# Numerical - Module.
+# Holds some basic mathematical messages that can be used by different numerical types.
+Module in: Numerical do
+
+  def abs = {
+    (self > 0)
+    |> if_true { self }
+    |> if_false { self * -1 }
+  }
+
+  def ** = { |power|
+    ((abs power) == 0) if_true { return 1 }
+
+    return self * (self ** (power - 1))
+  }
+
+  def expt = (**) # define expt to be the same as **
+
+  def - = {
+    self * -1
+  }
+
+  def negate = (-)
+
+  def fac = {
+    (self <= 1) if_true { return 1 }
+    self * ((self - 1) fac)
+  }
+
+  # maybe some more ...
+
+  def incr = { self += 1 }
+  def decr = { self -= 1 }
+
+  def ++ = { self incr }
+
+  def -- = { self decr }
+
+  def to = do |n|
+    block_given? if_true {
+      i = self
+      msg = (incr)
+
+      (i > n) if_true {
+        msg = (decr)
+      }
+
+      (i != n) while_true {
+        yield i
+        i msg  # increment or decrement i, based on value of msg
+      }
+    }
+  end
+
+  def times = {
+    i = self
+    (i > 0) while_true {
+      i decr
+      yield i
+    }
+  }
+end
+
+
+
+Class in: Boolean do
+
+  def if_true = {
+    # check (via some core routine in the vm) if self == true.
+    # if so: yield to block.
+    # finally, return self for easy chaining.
+    yield
+    self
+  }
+
+  def if_false = {
+    # similar to if_true, but only yield, if self == false.
+    yield
+    self
+  }
+
+  def while_true = {
+    self if_true {
+      yield
+      self while_true
+    }
+  }
+
+  def while_true = {
+    self if_false {
+      yield
+      self while_false
+    }
+  }
+
+end
+
+
+Module in: MyModule {
+  def self some_static_method = do |param1 and: param2|
+    return "bla_blubb"
+  end
+}
+
+
+Class in: Foo deriving: [Bar] {
+  self mixin: [Enumerable, Weirdo]
+}

data/lib/blocktalk/array.bt

@@ -0,0 +1,60 @@
+Class >> :Array do
+  %ruby{
+    alias_method :insert_original, :insert
+    alias_method :push_original, :push
+    alias_method :unshift_original, :unshift
+    alias_method :values_at_original, :values_at
+    alias_method :zip_original, :zip
+  }%
+
+  def rest = do
+    %ruby{
+      self[0..-1]
+    }%
+  end
+
+  def at = do |index put: value|
+    %ruby{
+      self[index] = value
+    }%
+  end
+
+  def insert = do |index_obj_arr|
+    %ruby{
+      self.insert_original(*index_obj_arr.flatten)
+    }%
+  end
+
+  def push = do |obj_arr|
+    %ruby{
+      if obj_arr.is_a?(Array)
+        self.push_original(*obj_arr)
+      else
+        self.push_original(obj_arr)
+      end
+    }%
+  end
+
+  def unshift = do |obj_arr|
+    %ruby{
+      if obj_arr.is_a?(Array)
+        self.unshift_original(*obj_arr)
+      else
+        self.unshift_original(obj_arr)
+      end
+    }%
+  end
+
+  def values_at = do |selector_arr|
+    %ruby{
+      self.values_at_original(*selector_arr)
+    }%
+  end
+
+  def zip = do |arg_arr|
+    %ruby{
+      self.zip_original(*arg_arr)
+    }%
+  end
+
+end

data/lib/blocktalk/string.bt

@@ -0,0 +1,9 @@
+Class >> :String do
+  def substitute = do |string with: subst_string|
+    self gsub: string with: subst_string
+  end
+
+  def substitute! = do |string with: subst_string|
+    self gsub!: string with: subst_string
+  end
+end

data/lib/blocktalk.bt

@@ -0,0 +1,3 @@
+# blocktalk standard library files
+
+require: "blocktalk/array"

data/lib/core.rb

@@ -0,0 +1,12 @@
+# expand search path correct subdir.
+$: << File.expand_path(File.dirname(__FILE__))
+
+require "kernel/array"
+require "kernel/class"
+require "kernel/codeblock"
+require "kernel/console"
+require "kernel/error"
+require "kernel/module"
+require "kernel/object"
+require "kernel/string"
+require "kernel/system"

data/lib/kernel/array.rb

@@ -0,0 +1,9 @@
+class Array
+  def rest
+    self[0..-1]
+  end
+
+  def at__set(index, value)
+    self[index] = value
+  end
+end

data/lib/kernel/class.rb

@@ -0,0 +1,46 @@
+class Class
+  def self.in(class_name_sym, &block)
+    self.in__subclassing(class_name_sym, Object, &block)
+  end
+
+  def self.in__subclassing(class_name_sym, superclass = Object, &block)
+    # try to find class via const_get
+    # if error occurs (not found), define a new class with the given name
+    begin
+      classobj = Kernel::const_get(class_name_sym)
+      classobj.class_eval(&block)
+    rescue
+      Kernel::const_set(class_name_sym, Class.new(superclass, &block))
+    end
+  end
+
+  def self.>>(class_name_sym, &block)
+    class_name = class_name_sym
+    superclass = Object # default
+
+    if class_name_sym.is_a?(Hash)
+      class_name = class_name_sym.keys.first
+      superclass = class_name_sym.values.first
+    end
+
+    self.in__subclassing(class_name, superclass, &block)
+  end
+
+  def extend(&block)
+    self.class_eval(&block)
+  end
+
+  def mixin(modules = [])
+    modules.each do |m|
+      self.class_eval do
+        include m
+      end
+    end
+  end
+
+  def meta_class
+    class << self
+      self
+    end
+  end
+end

data/lib/kernel/codeblock.rb

@@ -0,0 +1,57 @@
+module Kernel
+  class Codeblock < Proc
+
+    attr_reader :params, :block
+
+    def initialize(params = [], &block)
+      if params.size > 0 && (params.size != block.arity)
+        raise "Error: Codeblock's arity doesn't match given argument list."
+      else
+        super(&block)
+        @params = params
+        @block = block
+      end
+    end
+
+    def call(*args)
+      calling_args = []
+      args.rest.each do |arg_name_with_val|
+        name, val = arg_name_with_val
+        if name && val
+          pos = param_pos(name)
+          puts "pos: #{pos}"
+          calling_args[pos] = val
+        end
+      end
+      if calling_args.size > 0
+        super(*([args.first] + calling_args))
+      else
+        super(*args)
+      end
+    end
+
+    def param_pos(param_name)
+      if @params.include?(param_name)
+        @params.index(param_name)
+      else
+        nil
+      end
+    end
+
+    def while_true(&block)
+      while self.call
+        block.call
+      end
+    end
+
+    def while_false(&block)
+      while not self.call
+        block.call
+      end
+    end
+
+    def until(&block)
+      self.while_false(&block)
+    end
+  end
+end

data/lib/kernel/console.rb

@@ -0,0 +1,40 @@
+class Console
+  def self.puts(*args)
+    Kernel::puts *args
+  end
+
+  def self.print(*args)
+    Kernel::print *args
+  end
+
+  def self.putc(*args)
+    Kernel::putc(*args)
+  end
+
+  def self.printf(arg_array)
+    Kernel::printf(*arg_array)
+  end
+
+  def self.write(*args)
+    Kernel::print(*args)
+  end
+
+  def self.writeln(*args)
+    Kernel::puts(*args)
+  end
+
+  def self.gets(prompt_str = nil)
+    if prompt_str
+      self.print(prompt_str.to_s + " ")
+    end
+    Kernel::gets
+  end
+
+  def self.readln(prompt_str = nil)
+    gets(prompt_str)
+  end
+
+  def self.clear
+    puts "\e[H\e[2J"
+  end
+end

data/lib/kernel/error.rb

@@ -0,0 +1,11 @@
+class Error < StandardError
+  def self.raise(error_obj)
+    Kernel::raise error_obj
+  end
+end
+
+class RuntimeError
+  def self.raise(message)
+    Kernel::raise(message)
+  end
+end

data/lib/kernel/module.rb

@@ -0,0 +1,18 @@
+class Module
+  def self.in(module_name_sym, &block)
+    if Kernel::constants.include?(module_name_sym.to_s)
+      moduleobj = Kernel::const_get(module_name_sym)
+      moduleobj.module_eval(&block)
+    else
+      Kernel::const_set(module_name_sym, Module.new(&block))
+    end
+  end
+
+  def self.>>(module_name_sym, &block)
+    self.in(module_name_sym, &block)
+  end
+
+  def extend(&block)
+    self.module_eval(&block)
+  end
+end

data/lib/kernel/object.rb

@@ -0,0 +1,66 @@
+class Object
+
+  def if_true(true_block = nil)
+    if self == true
+      if true_block
+        true_block.call
+      elsif block_given?
+        yield
+      end
+    end
+  end
+
+  def if_true__if_false(true_block = nil, false_block = nil)
+    if self == true
+      if true_block
+        true_block.call
+      elsif block_given?
+        yield
+      end
+    else
+      if false_block
+        false_block.call
+      end
+    end
+  end
+
+  def if_false(&block)
+    if self == false
+      block.call
+    end
+  end
+
+  def if(&block)
+    if self
+      block.call
+    end
+  end
+
+  def unless(&block)
+    unless self
+      block.call
+    end
+  end
+
+  # this should get called, if we try to call a method on objects of
+  # ruby classes.
+  # it will try to find the correct ruby method-name & clall it.
+  def method_missing(name, *args, &block)
+    # probably a blocktalk_like method was called, when we actually
+    # ment a ruby method
+    splitted = name.to_s.split("__")
+    if splitted.size == 2
+      ruby_name = splitted.first
+
+      # hopefully, we got it right
+      # to make us not do the work again simply create the method for
+      # later use and then call it
+      arg_names = 0.upto(args.size - 1).collect{|i| "arg_#{i}"}
+      self.instance_eval "def #{name}(#{arg_names.join(',')}, &block); self.send(:#{ruby_name}, #{arg_names.join(',')}, &block); end;"
+      # now call!
+      self.send(ruby_name, *args, &block)
+    else
+      raise "Unknown method, don't know what to do: #{self.class}##{name}"
+     end
+  end
+end

data/lib/kernel/string.rb

@@ -0,0 +1,5 @@
+class String
+  def range_from__to(start_index, end_index)
+    self[start_index, end_index]
+  end
+end

data/lib/kernel/system.rb

@@ -0,0 +1,5 @@
+class System
+  def self.require(file)
+    Kernel::require(file)
+  end
+end

data/parser/helpers/method_definitions.rb

@@ -0,0 +1,31 @@
+module Blocktalk
+  module ASTHelpers
+    module MethodDefinitions
+      def ruby_method(method_name, params)
+        params_val = params.value
+        method_name_val = method_name.value
+
+        bang_or_question = nil
+
+        # check for bang or boolean methods (!/? at the end)
+        if method_name.text_value =~ /(!|\?)/
+          method_name_val = method_name_val[0..-2]
+          bang_or_question = method_name.text_value[-1].chr.to_s
+        end
+
+        param_names = params_val.collect{|p| p[:name].to_s[1..-1] if p[:name]}.reject{|p| p.nil?}
+        # methods with more than one parameter have names including
+        # the additional param-names, e.g.:
+        # def goto = do |place with: vehicle| ... end
+        # becomes: def goto_with(place, vehicle) ... end
+        if param_names.size > 0
+          method_name_val += "__" + param_names.join("__")
+        end
+
+        method_name_val += bang_or_question if bang_or_question
+
+        return method_name_val
+      end
+    end
+  end
+end

data/parser/helpers/methodcalls.rb

@@ -0,0 +1,56 @@
+module Blocktalk
+  module ASTHelpers
+    module Methodcalls
+      def generate_methodcall(receiver, message, passed_block = nil)
+        message_hash = message.value
+        message = message_hash[:message]
+        param_names = message_hash[:params].collect{|p| p.is_a?(Hash) ? p[:name] : nil}
+        param_values = message_hash[:params].collect{|p| p.is_a?(Hash) ? p[:value] : p.value}
+        message += param_names.join("__")
+
+        if message =~ /new_\S*/
+          message = "new"
+        end
+
+        # this happens, when we pass in a chained method call
+        # the string then is the already evaluated part of the chain...
+        eval_str = ""
+        if receiver.is_a?(String)
+          eval_str += "#{receiver}.#{message}("
+        else
+          eval_str += "#{receiver.value}.#{message}("
+        end
+        eval_str += "#{param_values.join(', ')}"
+
+        if passed_block && passed_block.class == Blocktalk::BlockLiteralNode
+          eval_str += "){" # start block
+
+          # check for block_params
+          if passed_block.params.respond_to?(:value)
+            eval_str += "|"
+            eval_str +=
+              passed_block.params.value.collect{|p| p[:identifier]}.join(",")
+            eval_str += "| "
+          end
+
+          eval_str += passed_block.body.value # insert block-body
+          eval_str += "}" # end block
+
+        elsif passed_block && passed_block.text_value =~ /&\S+/
+          # check for Proc-Objects passed to method as block
+          if params.size > 0
+            eval_str += ", "
+          end
+          eval_str += "&"
+          eval_str += passed_block.block_var_name.value
+          eval_str += ")"
+        else
+          # no block given -> method call is finished
+          eval_str += ")"
+        end
+
+        return eval_str
+      end
+    end
+  end
+end