bakkdoor-blocktalk 0.1.1 → 0.1.2

data/parser/nodes/block_literal.rb

@@ -0,0 +1,42 @@
+module Blocktalk
+  class BlockLiteralNode < Treetop::Runtime::SyntaxNode
+    def value
+      block_str = "Codeblock.new("
+
+      ruby_params_string = "" # for ruby params list to block
+
+      if params.respond_to?(:value)
+        ruby_params_string += "|"
+        names_and_identifiers = params.value
+
+        param_names = []
+        param_identifiers = []
+
+        names_and_identifiers.each do |pair|
+          if pair[:name]
+            param_names << pair[:name].to_s
+          else
+            param_names << "nil"
+          end
+
+          if pair[:identifier]
+            param_identifiers << pair[:identifier].to_s
+          end
+        end
+
+        block_str += "[" + param_names.select{|p| p}.join(",") + "]"
+
+        ruby_params_string += param_identifiers.join(",")
+        ruby_params_string += "| "
+      end
+
+
+      block_str += "){"
+
+      block_str += ruby_params_string
+
+      block_str += body.value
+      block_str += "}"
+    end
+  end
+end

data/parser/nodes/catch.rb

@@ -0,0 +1,22 @@
+module Blocktalk
+  class CatchNode < Treetop::Runtime::SyntaxNode
+    def value
+      if self.text_value.match(/catch\: \S+/)
+        rescue_str = "rescue #{error_class.identifier.value}"
+
+        # we have a block parameter
+        if catch_block.params.text_value.match(/\|[\s\S]*\|/)
+          block_param = catch_block.params.value.first
+          rescue_str += " => #{block_param[:identifier]};"
+        else
+          rescue_str += ";"
+        end
+
+        rescue_str += "#{catch_block.body.value}"
+        return rescue_str
+      else
+        return "rescue;#{catch_block.body.value}"
+      end
+    end
+  end
+end

data/parser/nodes/class_method_definition.rb

@@ -0,0 +1,15 @@
+module Blocktalk
+  class ClassMethodDefinitionNode < Treetop::Runtime::SyntaxNode
+    include ASTHelpers::MethodDefinitions
+
+    def value
+      if method_body.params.respond_to?(:value)
+        method_name_with_params = ruby_method(method_name, method_body.params)
+        "self.meta_class.class_eval{define_method(:#{method_name_with_params}, &#{method_body.value})}"
+      else
+        # no parameters given -> simply call define_method with a param-less block
+        "self.meta_class.class_eval{define_method(\"#{method_name.value}\", &#{method_body.body.value})}"
+      end
+    end
+  end
+end

data/parser/nodes/comment.rb

@@ -0,0 +1,7 @@
+module Blocktalk
+  class CommentNode < Treetop::Runtime::SyntaxNode
+    def value
+      nil
+    end
+  end
+end

data/parser/nodes/ensure.rb

@@ -0,0 +1,7 @@
+module Blocktalk
+  class EnsureNode < Treetop::Runtime::SyntaxNode
+    def value
+      "ensure; #{ensure_block.body.value}"
+    end
+  end
+end

data/parser/nodes/expression.rb

@@ -0,0 +1,7 @@
+module Blocktalk
+  class ExpressionNode < Treetop::Runtime::SyntaxNode
+    def value
+      subexpr.elements[0].value
+    end
+  end
+end

data/parser/nodes/identifier.rb

@@ -0,0 +1,7 @@
+module Blocktalk
+  class IdentifierNode < Treetop::Runtime::SyntaxNode
+    def value
+      self.text_value
+    end
+  end
+end

data/parser/nodes/integer_literal.rb

@@ -0,0 +1,7 @@
+module Blocktalk
+  class IntegerLiteralNode < Treetop::Runtime::SyntaxNode
+    def value
+      self.text_value.to_i
+    end
+  end
+end

data/parser/nodes/message_receiver.rb

@@ -0,0 +1,7 @@
+module Blocktalk
+  class MessageReceiverNode < Treetop::Runtime::SyntaxNode
+    def value
+      puts "in messagereceivernode"
+    end
+  end
+end

data/parser/nodes/message_with_params.rb

@@ -0,0 +1,8 @@
+module Blocktalk
+  class MessageWithParamsNode < Treetop::Runtime::SyntaxNode
+    def value
+      { :message => message.value,
+        :params => params.value}
+    end
+  end
+end

data/parser/nodes/message_without_params.rb

@@ -0,0 +1,10 @@
+module Blocktalk
+  class MessageWithoutParamsNode < Treetop::Runtime::SyntaxNode
+    def value
+      {
+        :message => message.value,
+        :params => []
+      }
+    end
+  end
+end

data/parser/nodes/method_definition.rb

@@ -0,0 +1,31 @@
+module Blocktalk
+  class MethodDefinitionNode < Treetop::Runtime::SyntaxNode
+    include ASTHelpers::MethodDefinitions
+
+    def value
+      if method_body.params.respond_to?(:value)
+        params_val = method_body.params.value
+        param_names = params_val.collect{|p| p[:name].to_s[1..-1] if p[:name]}.reject{|p| p.nil?}
+
+        method_name_val = ruby_method(method_name, method_body.params)
+
+        eval_str = ""
+        # check for constructor definition
+        # if we have a method called "initialize_*", we create the
+        # initialize method (ruby constructor) and inside call the
+        # defined method
+        if method_name_val =~ /initialize_\S*/
+          eval_str +=
+            "define_method(:initialize){|first_val,#{param_names.join(',')}| self.#{method_name_val}(first_val,#{param_names.join(',')})};"
+        end
+
+        # now simply define the method
+        eval_str += "define_method(:#{method_name_val}, &#{method_body.value})"
+        return eval_str
+      else
+        # no parameters given -> simply call define_method with a param-less block
+        "define_method(:#{method_name.value}){#{method_body.body.value}}"
+      end
+    end
+  end
+end

data/parser/nodes/methodcall.rb

@@ -0,0 +1,37 @@
+module Blocktalk
+  class MethodcallNode < Treetop::Runtime::SyntaxNode
+    include ASTHelpers::Methodcalls
+    def value
+      first_messagecall = ""
+
+      if looks_like_block?(first_passed_block_with_ws)
+        first_messagecall = generate_methodcall(receiver,
+                                                first_message,
+                                                first_passed_block_with_ws.passed_block)
+      else
+        first_messagecall = generate_methodcall(receiver, first_message)
+      end
+
+      chained_methodcalls = first_messagecall
+
+      messages.elements.each do |whitespace_with_message|
+        ws_w_msg = whitespace_with_message
+        chained_methodcalls =
+          if looks_like_block?(ws_w_msg.passed_block_with_ws)
+            generate_methodcall(chained_methodcalls,
+                                ws_w_msg.message,
+                                ws_w_msg.passed_block_with_ws.passed_block)
+          else
+            generate_methodcall(chained_methodcalls,
+                                ws_w_msg.message)
+          end
+      end
+
+      chained_methodcalls
+    end
+
+    def looks_like_block?(node)
+      node.text_value =~ /(\{|do)/
+    end
+  end
+end

data/parser/nodes/multiple_methodcall.rb

@@ -0,0 +1,28 @@
+module Blocktalk
+  class MultipleMethodcallNode < Treetop::Runtime::SyntaxNode
+    def value
+      eval_str = ""
+      receiver_val = receiver.value
+      messages.elements.each do |m|
+        message_hash = m.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("__")
+
+        eval_str += "#{receiver_val}.#{message}("
+        eval_str += "#{param_values.join(', ')}"
+        eval_str += ");"
+      end
+
+      message_hash = final_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("__")
+
+      eval_str += "#{receiver_val}.#{message}(#{param_values.join(', ')})"
+      eval_str
+    end
+  end
+end

data/parser/nodes/operator_message.rb

@@ -0,0 +1,8 @@
+module Blocktalk
+  class OperatorMessageNode < Treetop::Runtime::SyntaxNode
+    def value
+      { :message => operator_name.value,
+        :params => [param_value]}
+    end
+  end
+end

data/parser/nodes/require.rb

@@ -0,0 +1,25 @@
+module Blocktalk
+  class RequireNode < Treetop::Runtime::SyntaxNode
+    def value
+      parser = BlocktalkParser.new
+
+      file = parse_file.text_value
+
+      unless file.include?(".bt")
+        file += ".bt"
+      end
+
+      file = file.gsub(/\"/, "")
+
+      $:.each do |path|
+        if File.exists?("#{path}/#{file}")
+          ast = parser.parse IO.read("#{path}/#{file}")
+          ast.evaluate
+          return nil # only require once!
+        end
+      end
+
+      nil
+    end
+  end
+end

data/parser/nodes/return.rb

@@ -0,0 +1,7 @@
+module Blocktalk
+  class ReturnNode < Treetop::Runtime::SyntaxNode
+    def value
+      "return #{ret_val.value}"
+    end
+  end
+end

data/parser/nodes/root.rb

@@ -0,0 +1,15 @@
+module Blocktalk
+  class RootNode < Treetop::Runtime::SyntaxNode
+    def evaluate
+      self.value
+    end
+
+    def value
+      self.exprs.elements.each do |e|
+        if e.elements[0].respond_to?(:value)
+          Evaluator.add e.elements[0].value
+        end
+      end
+    end
+  end
+end

data/parser/nodes/string.rb

@@ -0,0 +1,7 @@
+module Blocktalk
+  class StringLiteralNode < Treetop::Runtime::SyntaxNode
+    def value
+      "\"" + self.string_val.elements.collect{|e| e.value}.join("") + "\""
+    end
+  end
+end

data/parser/nodes/subexpression.rb

@@ -0,0 +1,7 @@
+module Blocktalk
+  class SubexpressionNode < Treetop::Runtime::SyntaxNode
+    def value
+      subexpr.value
+    end
+  end
+end

data/parser/nodes/super_call.rb

@@ -0,0 +1,12 @@
+module Blocktalk
+  class SuperCallNode < Treetop::Runtime::SyntaxNode
+    def value
+      params_str = ""
+      if params.respond_to?(:value)
+        # we've got some params!
+        params_str = params.value.collect{|p| p[:value]}.join(",")
+      end
+      return "super(#{params_str})"
+    end
+  end
+end

data/parser/nodes/try.rb

@@ -0,0 +1,7 @@
+module Blocktalk
+  class TryNode < Treetop::Runtime::SyntaxNode
+    def value
+      "begin; #{try_block.body.value}; end;"
+    end
+  end
+end

data/parser/nodes/yield.rb

@@ -0,0 +1,18 @@
+module Blocktalk
+  class YieldNode < Treetop::Runtime::SyntaxNode
+    def value
+#       array_str =  yieldval.value
+#       array_str = array_str[1..-1]
+#       array_str = array_str[0..-2]
+
+#       yieldparams = []
+#       array_str.split(/\s*,\s*/).each do |elem|
+#         yieldparams << elem
+#       end
+#      "yield(#{yieldparams.join(",")})"
+
+      # not needed, as ArrayLiteralNode returns it correctly for now...
+      "yield(#{yieldval.text_value})"
+    end
+  end
+end

data/parser/nodes.rb

@@ -0,0 +1,29 @@
+$: << File.expand_path(File.dirname(__FILE__))
+
+#require helpers first
+require "helpers/methodcalls"
+require "helpers/method_definitions"
+
+require "nodes/block_literal"
+require "nodes/catch"
+require "nodes/class_method_definition"
+require "nodes/comment"
+require "nodes/ensure"
+require "nodes/expression"
+require "nodes/identifier"
+require "nodes/integer_literal"
+require "nodes/message_receiver"
+require "nodes/message_without_params"
+require "nodes/message_with_params"
+require "nodes/methodcall"
+require "nodes/method_definition"
+require "nodes/multiple_methodcall"
+require "nodes/operator_message"
+require "nodes/return"
+require "nodes/require"
+require "nodes/root"
+require "nodes/string"
+require "nodes/subexpression"
+require "nodes/super_call"
+require "nodes/try"
+require "nodes/yield"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bakkdoor-blocktalk
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors: 
 - Christopher Bertels
@@ -30,8 +30,75 @@ extensions: []
 
 extra_rdoc_files: []
 
-files: []
-
+files: 
+- README.markdown
+- benchmark.bt
+- TODO
+- LICENSE
+- evaluator.rb
+- grammar/blocktalk.tt
+- grammar/blocktalk.rb
+- lib/core.rb
+- lib/kernel
+- lib/kernel/console.rb
+- lib/kernel/array.rb
+- lib/kernel/error.rb
+- lib/kernel/module.rb
+- lib/kernel/string.rb
+- lib/kernel/class.rb
+- lib/kernel/codeblock.rb
+- lib/kernel/system.rb
+- lib/kernel/object.rb
+- lib/blocktalk
+- lib/blocktalk/string.bt
+- lib/blocktalk/array.bt
+- lib/blocktalk.bt
+- bin/blocktalk
+- examples/test3.bt
+- examples/fac.bt
+- examples/chained_method_call.bt
+- examples/exceptions.bt
+- examples/string_interpol.bt
+- examples/test2.bt
+- examples/ruby_methods.bt
+- examples/multiple_methodcall.bt
+- examples/linecounter.bt
+- examples/require.bt
+- examples/portscan.bt
+- examples/classes_modules.bt
+- examples/test.bt
+- examples/string_test.bt
+- examples/inline_ruby.bt
+- language-spec/blocktalk-lang-spec.bt
+- language-spec/blocktalk-example.bt
+- parser/helpers
+- parser/helpers/method_definitions.rb
+- parser/helpers/methodcalls.rb
+- parser/nodes.rb
+- parser/nodes
+- parser/nodes/message_without_params.rb
+- parser/nodes/block_literal.rb
+- parser/nodes/integer_literal.rb
+- parser/nodes/require.rb
+- parser/nodes/expression.rb
+- parser/nodes/try.rb
+- parser/nodes/comment.rb
+- parser/nodes/multiple_methodcall.rb
+- parser/nodes/root.rb
+- parser/nodes/string.rb
+- parser/nodes/message_receiver.rb
+- parser/nodes/method_definition.rb
+- parser/nodes/subexpression.rb
+- parser/nodes/catch.rb
+- parser/nodes/identifier.rb
+- parser/nodes/ensure.rb
+- parser/nodes/operator_message.rb
+- parser/nodes/return.rb
+- parser/nodes/yield.rb
+- parser/nodes/class_method_definition.rb
+- parser/nodes/super_call.rb
+- parser/nodes/methodcall.rb
+- parser/nodes/message_with_params.rb
 has_rdoc: false
 homepage: http://www.adztec-independent.de
 post_install_message: