bakkdoor-blocktalk 0.1.1 → 0.1.2

data/grammar/blocktalk.tt

@@ -0,0 +1,463 @@
+grammar Blocktalk do
+  # starting point for the parser.
+  # a blocktalk programm consists of expressions & comments.
+  rule blocktalk_programm do
+    ws* exprs:(expression)* ws* <RootNode>
+  end
+
+  # comments start with '#' and end at the end of a line, as in ruby
+  rule comment do
+    '#' (![\n] .)* [\n]? <CommentNode>
+  end
+
+  # expressions start here
+
+  # an expression is one of the following:
+  # assignment, method_call, literal or subexpression
+  rule expression do
+    (subexpr:(method_definition / require_statement / return_statement / yield_statement
+              /
+              try_expression / catch_expression / ensure_expression
+              /
+              super_call / multiple_method_call / method_call / assignment / literal
+              /
+              subexpression / inline_ruby / comment)
+     ('$' / (ws* newline?)))
+    <ExpressionNode>
+  end
+
+  rule method_definition do
+    spaces* 'def' spaces+ method_name:(message_name)  ws* '=' ws* method_body:(block_literal)
+    <MethodDefinitionNode>
+      /
+    spaces* 'def' spaces+  'self ' method_name:(message_name) ws* '=' ws* method_body:(block_literal)
+    <ClassMethodDefinitionNode>
+  end
+
+  rule require_statement do
+    'require:' spaces+ parse_file:string_literal <RequireNode>
+  end
+
+  rule return_statement do
+    'return' ':'? ' ' ret_val:(subexpression / identifier / literal) <ReturnNode>
+  end
+
+  rule yield_statement do
+    'yield' ':'? ' ' yieldval:(array_literal) <YieldNode>
+  end
+
+  rule try_expression do
+    'try' ' '? try_block:(block_literal) <TryNode>
+  end
+
+  rule catch_expression do
+    'catch' error_class:(': ' identifier ' ')? ' '? catch_block:(block_literal) <CatchNode>
+  end
+
+  rule ensure_expression do
+    'ensure' ' '? ensure_block:(block_literal) <EnsureNode>
+  end
+
+  # a subexpression is an expression surrounded by parenthesis for grouping.
+  # e.g.: (gets to_i) + 3
+  rule subexpression do
+    '(' ws* subexpr:expression ws* ')' <ExpressionNode>
+  end
+
+  # an assignment typically looks like this:
+  # identifier = value (value is either an (sub)expression, an identifier or a literal
+  rule assignment do
+    target:(identifier) ws* '=' ws* val:(expression / identifier / literal) {
+      def value
+        if val.respond_to?(:subexpr)
+          "#{target.value} = #{val.subexpr.value}"
+        else
+          "#{target.value} = #{val.value}"
+        end
+      end
+    }
+  end
+
+
+  # call method of superclass (as in ruby)
+  rule super_call do
+    'super' params:(message_params)? <SuperCallNode>
+  end
+
+  # calling multiple methods on the same object in a row, seperated by
+  # semicolons (as in smalltalk)
+  rule multiple_method_call do
+    receiver:(message_receiver) ' '
+    messages:(message:(message_with_params / message_without_params) spaces* ';' ws*)+
+      final_message:(message_with_params / message_without_params) ws*
+      <MultipleMethodcallNode>
+  end
+
+  # a method_call is characterized by a receiver, a message and optional parameters:
+  # e.g.: receiver message
+  #       receiver message: param_value
+  #       receiver message: param1_value param2: param2_value ...
+  # additionally, a method call can be chained as in:
+  # obj message1 message2 message3: param1 ...
+  # equivalent to this ruby code:
+  # obj.message1().message2().message3(param1) ...
+  rule method_call do
+    receiver:(message_receiver) ' '
+    first_message:(operator_message / message_with_params / message_without_params)
+    first_passed_block_with_ws:(' '? passed_block:(block_literal_do_end / block_literal_curly_braces / '&' block_var_name:identifier))?
+    messages:(' ' message:(message_with_params / message_without_params)
+              passed_block_with_ws:(' '?
+                                    passed_block:(block_literal_do_end / block_literal_curly_braces / '&' block_var_name:identifier))?)*
+    <MethodcallNode>
+  end
+
+  # a message receiver is one of the following:
+  # - message_without_params, e.g.: "42" to_i to_f # -> 42.0
+  # - literals, e.g. 123, 123.456, [1,2,3], {:a => 1, :b => 2}, "hello world", ?C etc.
+  # subexpressions, e.g. (3 + 4), ("foo" to_sym) etc.
+  rule message_receiver do
+    (literal / identifier) / subexpression
+  end
+
+  # a message with parameters passed to it should look like this:
+  # receiver message: param1_value param2: param2_value param3: param3_value etc.
+  rule message_with_params do
+    message:(message_name) params:(message_params) <MessageWithParamsNode>
+  end
+
+  # a message without parameters passed to it looks like this:
+  # receiver message
+  rule message_without_params do
+    message:(message_name) !message_params <MessageWithoutParamsNode>
+  end
+
+  rule operator_message do
+    operator_name:(operator) ' ' param_value !message_params <OperatorMessageNode>
+  end
+
+  # message parameters look like this:
+  # first_param param2_name: param2_value param3_name: param3_value
+  # but the additional parameters beyond the first one are optional.
+  rule message_params do
+    first_param:(first_param) rest_params:(' ' parameter:param)* {
+      def value
+        [first_param.value] + rest_params.elements.map do |space_and_param|
+          space_and_param.parameter.value
+        end
+      end
+    }
+  end
+
+  # the first_param is the one that gets passed to a message in the first position.
+  # it's param_name is the message_name, so to speak.
+  rule first_param do
+    ':' ' ' first_param_value:(param_value) {
+      def value
+        {:name => nil, :value => first_param_value.value}
+      end
+    }
+  end
+
+  rule param do
+    param_name ' ' param_value:(param_value) {
+      def value
+        #[param_name.value, param_value.value]
+        #param_value
+        {:name => param_name.value, :value => param_value.value}
+      end
+    }
+  end
+
+  rule param_name do
+    identifier ':' {
+      def value
+        identifier.value
+      end
+    }
+  end
+
+  rule param_value do
+    literal
+    /
+    identifier
+    /
+    subexpression
+  end
+
+  # literals
+
+  rule literal do
+    string_literal / symbol_literal / float_literal /int_literal / char_literal / array_literal / hash_literal / block_literal / regex_literal
+  end
+
+  rule string_literal do
+    '"' string_val:(string_interpolation / string_char)* '"' <StringLiteralNode>
+      / "'" string_val:(string_interpolation / string_char_single_quote)* "'" <StringLiteralNode>
+  end
+
+  rule string_char do
+    !'"' char:(.) {
+      def value
+        self.char.text_value
+      end
+    }
+  end
+
+  rule string_char_single_quote do
+    !"'" char:(.) {
+      def value
+        self.char.text_value
+      end
+    }
+  end
+
+  rule string_interpolation do
+    '#{' spaces* expr:(expression / identifier / literal) spaces* '}' {
+      def value
+        val = "\#\{"
+        val += expr.respond_to?(:value) ? expr.value : expr.subexpr.value
+        val += "\}"
+      end
+    }
+  end
+
+  rule symbol_literal do
+    ':' symbol_name:(!':' identifier) {
+      def value
+        (':' + symbol_name.text_value).to_sym
+      end
+    }
+  end
+
+  rule int_literal do
+    sign? non_zero_digit digit* <IntegerLiteralNode> / [0] <IntegerLiteralNode>
+  end
+
+  rule float_literal do
+    sign? digit+ '.' digit+
+  {
+    def value
+      self.text_value.to_f
+    end
+  }
+  end
+
+  rule char_literal do
+    '?' val:[a-zA-Z0-9_] {
+    def value
+      val.each_byte{|b| b}
+    end
+  }
+  end
+
+  rule array_literal do
+    '[' ws* first_item:(literal / identifier)? ws* rest_items:(',' ws* item:(literal / identifier))* ws* ']' {
+        def value
+          if self.text_value =~ /\[\s*\]/
+            "[]"
+          else
+            #[first_item.value] + rest_items.elements.collect{ |ws_and_items| ws_and_items.item.value }
+            array_str = "[#{first_item.value},"
+            rest_items.elements.each do |ws_and_items|
+              array_str += "#{ws_and_items.item.value},"
+            end
+            array_str += "]"
+            return array_str
+          end
+        end
+      }
+    end
+
+  rule hash_literal do
+    # '{' ws* '}' /
+    '{' ws* first_entry:(hash_entry)? ws* rest_pairs:(',' ws* pair:(hash_entry))*  ws* '}' {
+      def value
+        if self.text_value =~ /\{\s*\}/
+          return "{}"
+        else
+          hash_str = "{"
+          first_pair = first_entry.value
+          hash_str += "#{first_pair[0]} => #{first_pair[1]},"
+          rest_pairs.elements.each do |ws_and_pair|
+            pair = ws_and_pair.pair
+            hash_str += "#{pair[0]} => #{pair[1]},"
+          end
+          hash_str += "}"
+
+          return hash_str
+        end
+      end
+    }
+  end
+
+  # hash entry: 'key => value'
+  rule hash_entry do
+    key:(literal / identifier) ws* '=>' ws* val:(literal / identifier) {
+      def value
+        [key.value, val.value]
+      end
+    }
+  end
+
+  rule block_literal do
+    (block_literal_do_end / block_literal_curly_braces)
+  end
+
+  rule block_literal_do_end do
+    do_keyword ws* !hash_entry ws* params:(block_params)? ws*
+      body:(block_body) ws*
+    end_keyword
+    <BlockLiteralNode>
+
+  end
+
+  rule block_literal_curly_braces do
+    '{' ws* !hash_entry ws* params:(block_params)? ws*
+      body:(block_body) ws*
+    '}'
+    <BlockLiteralNode>
+  end
+
+  rule block_body do
+    ws* exprs:(expression)+ ws* {
+      def value
+        body_str = ""
+        body_str += exprs.elements.collect{|e| e.elements[0].value}.join(";")
+        return body_str
+      end
+    }
+  end
+
+  # block parameters (e.g. |a,b,c|)
+  rule block_params do
+    '|' params:(block_param)+ '|' {
+      def value
+#        block_param_str = "|"
+#        block_param_str += params.elements.collect{|param| param.value}.join(",")
+#        block_param_str += "| "
+#        return block_param_str
+        params.elements.collect{|param| param.value}
+      end
+    }
+  end
+
+  rule block_param do
+    (ws* param_name:(identifier ':')? ' '* param_name_val:(identifier) (ws*) / (ws+ param_name_val:(identifier))) {
+      def value
+        # holds param name (if given) with param value (the identifier in the body of the block)
+        name_identifier_pair = {}
+        if param_name.text_value =~ /\S+\:/
+          # return the param-name as a symbol (start with a colon)
+          # without the final colon & space, since it's not part of the name
+          name_identifier_pair[:name] = ":#{param_name.text_value[0..-2]}"
+        end
+        name_identifier_pair[:identifier] = param_name_val.value
+        return name_identifier_pair
+      end
+    }
+  end
+
+  rule regex_literal do
+    '/' (!'/' .)* '/' {
+      def value
+        self.text_value
+      end
+    }
+  end
+
+  # we allow some inline ruby in blocktalk
+  # (mainly as a help for defining some standard library methods etc.)
+  # syntax: %ruby{ ... }%
+  rule inline_ruby do
+    '%ruby' ws* '{' ws* ruby_code:(comment / (!'}%' .))+  '}%' {
+      def value
+        return_val = ""
+        ruby_code.elements.each do |e|
+          unless e.respond_to?(:value) # when NOT a comment
+            return_val += e.text_value.gsub(/[\n\t]/, ";").gsub(/\s+/, " ")
+          else
+            # check if its actually a comment, or just a string
+            # interpolation - I know, it's ugly :(
+            if e.text_value =~ /#\{\S*\}/
+              # if it's just a string interpolation, also return it
+              return_val += e.text_value + ";"
+            end
+          end
+        end
+        return_val
+      end
+    }
+  end
+
+
+  # other rules
+
+  # identifiers are variable & possible methodnames, class & module
+  # names - basically anything, that you can store something in or
+  # assign to.
+  rule identifier do
+    ('@' / '@@')? ([a-zA-Z]+ / '$' [0-9]) [a-zA-Z0-9_]* <IdentifierNode>
+  end
+
+  # possible names for messages / methods
+  rule message_name do
+    [a-zA-Z]+ [a-zA-Z0-9_]* ('?' / '!' / '=')? {
+      def value
+        self.text_value
+      end
+    }
+  end
+
+  # operator name combinations
+  rule operator do
+    ('=' operator_symbol+) / (operator_symbol '=' operator_symbol*) / operator_symbol+ {
+      def value
+        self.text_value
+      end
+    }
+  end
+
+  rule operator_symbol do
+    ('<=' / '>='/ '<' / '>' / '==' / '!=' / '+=' / '-=' / '&' / '.' / '+' / '-' / '/' / '*' / '|' / '=~')
+  end
+
+  # whitespace (with newline)
+  rule ws do
+    [\n\s\t]+
+  end
+
+  # whitespace (without newline)
+  rule spaces do
+    [\s\t]+
+  end
+
+  # newline character
+  rule newline do
+    [\n]+
+  end
+
+  # the 'do' keyword.
+  rule do_keyword do
+    'do' ![a-zA-Z0-9_] &ws
+  end
+
+  # the 'end' keyword
+  rule end_keyword do
+    'end' ![a-zA-Z0-9_]
+  end
+
+  # digits between 1 and 9
+  rule non_zero_digit do
+    [1-9]
+  end
+
+  # digits
+  rule digit do
+    [0-9]
+  end
+
+  # prefix sign for number literals
+  rule sign do
+    ('+' / '-')
+  end
+end

data/language-spec/blocktalk-example.bt

@@ -0,0 +1,38 @@
+System require: "message-lang-spec"
+
+File open: "test.txt" mode: "w" do |f|
+  # write three lines to 'test.txt' and close afterwards (done in File#open)
+  f puts: "what's up, dog?!"
+  f puts: "crazy shit, yo!"
+  f puts: "hahaha!!"
+end
+
+# print:
+# 10
+# 9
+# 8
+# ..
+# 0
+# to Console:
+10 to: 0 do |i|
+  Console puts: i
+end
+
+# same again
+i = 0
+(i < 10) while_true: do |i|
+  Console puts: i
+  i incr # increment i
+  # or:
+  #i ++
+end
+
+
+numbers = [1,2,3,4,5] select: {|i| i < 3} # will return [1,2]
+numbers each: do |i|
+  Console puts: i
+end
+
+(1 .. 100) each: {|i| Console puts: i}
+
+squares = (1 .. 100) collect: {|i| i * i}