pione 0.2.2 → 0.3.0

data/lib/pione/lang/common-parser.rb

@@ -0,0 +1,202 @@
+module Pione
+  module Lang
+    # CommonParser provides a set of symbols, keywords, and utility parsers.
+    module CommonParser
+      include Parslet
+
+      #
+      # symbols
+      #
+
+      SYMBOLS = {
+        :squote => '\'',
+        :dquote => '"',
+        :backslash => "\\",
+        :dot => '.',
+        :comma => ',',
+        :lparen => '(',
+        :rparen =>')',
+        :lbrace => '{',
+        :rbrace => '}',
+        :slash => '/',
+        :plus => '+',
+        :minus => '-',
+        :question => '?',
+        :vbar => '|',
+        :ampersand => '&',
+        :doller => '$',
+        :colon => ':',
+        :equals => '=',
+        :exclamation => '!',
+        :less_than => '<',
+        :greater_than => '>',
+        :asterisk => '*',
+        :percent => '%',
+        :atmark => '@',
+        :hat => '^',
+        :sharp => '#',
+        :lsbracket => '[',
+        :rsbracket => ']'
+      }
+
+      # make puctuation rules
+      SYMBOLS.each do |key, val|
+        rule(key) { str(val) }
+        rule(("%s!" % key).to_sym) { str(val).or_error("it should be '%s'" % val) }
+      end
+
+      # +symbols+ matches all symbols in PIONE document.
+      rule(:symbols) {
+        SYMBOLS.keys.inject(nil) do |res, elt|
+          res ? res | send(elt) : send(elt)
+        end
+      }
+
+      #
+      # keywords
+      #
+
+      KEYWORDS = {
+        :keyword_Rule => 'Rule',
+        :keyword_Flow => 'Flow',
+        :keyword_Action => 'Action',
+        :keyword_End => 'End',
+        :keyword_input => 'input',
+        :keyword_output => 'output',
+        :keyword_param => 'param',
+        :keyword_Param => 'Param',
+        :keyword_basic => 'basic',
+        :keyword_Basic => 'Basic',
+        :keyword_advanced => 'advanced',
+        :keyword_Advanced =>  'Advanced',
+        :keyword_feature => 'feature',
+        :keyword_rule => 'rule',
+        :keyword_if => 'if',
+        :keyword_else => 'else',
+        :keyword_case => 'case',
+        :keyword_when => 'when',
+        :keyword_end => 'end',
+        :keyword_package => 'package',
+        :keyword_true => 'true',
+        :keyword_false => 'false',
+        :keyword_and => 'and',
+        :keyword_or => 'or',
+        :keyword_null => 'null',
+        :keyword_constraint => 'constraint',
+        :keyword_bind => 'bind'
+      }
+
+      # make keywords
+      KEYWORDS.each do |key, val|
+        rule(key) { str(val) }
+      end
+
+      # +keywords+ matches all keywords in PIONE document.
+      rule(:keywords) {
+        KEYWORDS.keys.inject(nil) do |res, elt|
+          res ? res | send(elt) : send(elt)
+        end
+      }
+
+      #
+      # utility parsers
+      #
+
+      # +eof+ is parslet version of "End of File".
+      rule(:eof) { any.absent? }
+
+      # +newline+ matches newline characters.
+      rule(:newline) { str(";") | str("\n") }
+
+      # +binding_operator+ matches operator mark in variable binding declarations or parameter declarations.
+      rule(:binding_operator) { colon >> equals }
+      rule(:binding_operator!) { binding_operator.or_error("it should be :=") }
+
+      # +generating_operator+ matches operator mark in package binding declarations.
+      rule(:generating_operator) { less_than >> minus }
+      rule(:generating_operator!) { generating_operator.or_error("it should be <-") }
+
+      # +reverse_message_operator+ matches operator mark of reverse messages.
+      rule(:reverse_message_operator) { colon >> colon }
+      rule(:reverse_message_operator!) { reverse_message_operator.or_error("it should be ::") }
+
+      # +comment+ matches comment strings.
+      rule(:comment) { str("#") >> (newline.absent? >> any).repeat }
+
+      # +identifier+ matches any sequences excluding space, symbols, and line
+      # end.
+      rule(:identifier) {
+        identifier_head_character >> identifier_tail
+      }
+
+      rule(:identifier_head_character) {
+        (space | symbols | digit | line_end).absent? >> any
+      }
+
+      rule(:identifier_tail) {
+        identifier_tail_character.repeat >> identifier_special_tail_character.maybe
+      }
+
+      rule(:identifier_tail_character) {
+        (space | symbols | line_end).absent? >> any
+      }
+
+      rule(:identifier_special_tail_character) { question | exclamation }
+
+      rule(:capital_identifier) { match("[A-Z]") >> identifier_tail }
+      rule(:small_identifier) { match("[a-z]") >> identifier_tail }
+
+      # +digit+ matches 0-9.
+      rule(:digit) { match('[0-9]') }
+
+      # +number+ matches positive/negative numbers.
+      rule(:number) { match('[+-]').maybe >> digit.repeat(1) }
+      rule(:number!) { number.or_error("it should be number") }
+
+      # +space+ matches sequences of space character, tab, or comment.
+      rule(:space) { (match("[ \t]") | comment).repeat(1) }
+
+      # +space?+ matches +space+ or empty.
+      rule(:space?) { space.maybe }
+
+      # +pad+ matches sequences of space character, tab, newline, or comment.
+      rule(:pad) { (match("[ \t\n]") | comment).repeat(1) }
+
+      # +pad?+ matches +pad+ or empty.
+      rule(:pad?) { pad.maybe }
+
+      # +line_end+ matches a space sequence until line end.
+      rule(:line_end) { space? >> (newline | eof) }
+
+      # +empty_line+ matches an empty line.
+      rule(:empty_line) { space? >> newline | space >> eof }
+      rule(:empty_line?) { empty_line.maybe }
+
+      # +empty_lines+ matches empty lines.
+      rule(:empty_lines) { empty_line.repeat(1) >> eof.maybe }
+      rule(:empty_lines?) { empty_lines.maybe }
+
+
+
+      #
+      # utility methods
+      #
+
+      # Enclose the atom by "space?".
+      def spaced?(atom)
+        space? >> atom >> space?
+      end
+
+      # Enclose the atom by "pad?".
+      def padded?(atom)
+        pad? >> atom >> pad?
+      end
+
+      # Create an atom that matches a line with the content.
+      def line(content)
+        space? >> content >> line_end
+      end
+    end
+  end
+end
+

data/lib/pione/lang/conditional-branch-parser.rb

@@ -0,0 +1,57 @@
+module Pione
+  module Lang
+    # ConditionalBranchParser is a set of parsers for conditional branch "if" and "case".
+    module ConditionalBranchParser
+      include Parslet
+
+      #
+      # outline
+      #
+
+      # CONDITIONAL_BRANCHES is a list of conditional branchs in PIONE language.
+      CONDITIONAL_BRANCHES = [:if_branch, :case_branch]
+
+      # +conditional_branch+ matches all conditional branches.
+      rule(:conditional_branch) {
+        CONDITIONAL_BRANCHES.inject(nil) {|res, elt| res ? res | send(elt) : send(elt)}
+      }
+
+      #
+      # branch
+      #
+
+      # +if_branch+ matches +if+ conditional branches.
+      rule(:if_branch) {
+        (if_branch_header >> conditional_branch_context.as(:true_context) >> else_context.maybe >> branch_end!).as(:if_branch)
+      }
+
+      # +if_branch_header+ matches condition of +if+ branch.
+      rule(:if_branch_header) {
+        line(keyword_if.as(:declarator) >> space? >> expr!("condition of if branch not found").as(:expr))
+      }
+
+      # +else_context+ matches +else+ block.
+      rule(:else_context) { line(keyword_else) >> conditional_branch_context.as(:else_context) }
+
+      # +branch_end+ matches conditional branch block end.
+      rule(:branch_end) { line(keyword_end) }
+      rule(:branch_end!) { branch_end.or_error("conditional branch end not found") }
+
+      # +case_branch+ matches +case+ conditional branches.
+      rule(:case_branch) {
+        (case_branch_header >> when_contexts >> else_context.maybe >> branch_end!).as(:case_branch)
+      }
+
+      # +case_branch_header+ matches +case+ branch beginning.
+      rule(:case_branch_header) { line(keyword_case.as(:declarator) >> space? >> expr!.as(:expr)) }
+
+      # +when_context+ matches +when+ contexts.
+      rule(:when_context) { when_context_header >> conditional_branch_context.as(:context) }
+      rule(:when_contexts) { when_context.repeat.as(:when_contexts) }
+
+      # +when_context_header+ matches +when+ context block.
+      rule(:when_context_header) { line(keyword_when >> space? >> expr.as(:expr)) }
+    end
+  end
+end
+

data/lib/pione/lang/conditional-branch-transformer.rb

@@ -0,0 +1,36 @@
+module Pione
+  module Lang
+    # ConditionalBranchTransformer is a transformer for all branches.
+    module ConditionalBranchTransformer
+      include Util::ParsletTransformerModule
+
+      # Transform +if_branch+ into +Lang::IFBranch+.
+      rule(:if_branch => subtree(:tree)) {
+        # condition and contexts
+        expr = tree[:expr]
+        true_context = tree[:true_context]
+        else_context = tree[:else_context] || Lang::ConditionalBranchContext.new([])
+
+        # make branch
+        Lang::IfBranch.new(expr, true_context, else_context).tap do |branch|
+          line, col = tree[:declarator].line_and_column
+          branch.set_source_position(package_name, filename, line, col)
+        end
+      }
+
+      # Transform +case_branch+ into +Lang::CaseBranch+.
+      rule(:case_branch => subtree(:tree)) {
+        # condition and contexts
+        condition = tree[:expr]
+        when_contexts = tree[:when_contexts].map {|c| [c[:expr], c[:context]]}
+        else_context = tree[:else_context] || Lang::ConditionalBranchContext.new([])
+
+        # make branch
+        Lang::CaseBranch.new(condition, when_contexts, else_context).tap do |branch|
+          line, col = tree[:declarator].line_and_column
+          branch.set_source_position(package_name, filename, line, col)
+        end
+      }
+    end
+  end
+end

data/lib/pione/lang/conditional-branch.rb

@@ -0,0 +1,73 @@
+module Pione
+  module Lang
+    # ConditionalBranch is a base class for all conditional branches. PIONE's
+    # branch works as the function that controls availability of declarations.
+    class ConditionalBranch < StructX
+      include Util::Positionable
+    end
+
+    # IfBranch is a class for +if+ branches.
+    class IfBranch < ConditionalBranch
+      member :expr         # condition
+      member :true_context # true-context
+      member :else_context # else-context
+
+      # Validate inner contexts based on the list of acceptances.
+      def validate(acceptances)
+        true_context.validate(acceptances)
+        else_context.validate(acceptances)
+      end
+
+      # Return suitable context in the environment.
+      def eval(env)
+        # evaluate the condition
+        res = expr.eval!(env)
+
+        # check type of the result
+        unless res.is_a?(BooleanSequence)
+          raise StructuralError.new(BooleanSequence, expr.pos)
+        end
+
+        # return true_context when it is true
+        return true_context if res.value
+
+        # or return else_context when the context exists
+        return else_context if else_context
+
+        # otherwise return empty context
+        return ConditionalBranchContext.new
+      end
+
+      def eval!(env)
+        eval(env).eval!(env)
+      end
+    end
+
+    # CaseBranch is a class for +case+ branches.
+    class CaseBranch < ConditionalBranch
+      member :expr          # conditional value
+      member :when_contexts # when contexts(list of pair of expr and context)
+      member :else_context  # else context
+
+      # Validate inner contexts based on the list of acceptances.
+      def validate(acceptances)
+        when_contexts.each {|_expr, _context| _context.validate(acceptances)}
+        else_context.validate(acceptances)
+      end
+
+      # Return suitable context in the environment.
+      def eval(env)
+        # evaluate the condition
+        val = expr.eval!(env)
+
+        # return matched branch's context
+        _, matched = when_contexts.find do |_expr, _context|
+          val.call_pione_method(env, "==*", [_expr]).value
+        end
+
+        # return matched context, else-context, or empty context
+        return matched || else_context || ConditionalBranchContext.new
+      end
+    end
+  end
+end

data/lib/pione/lang/context-parser.rb

@@ -0,0 +1,39 @@
+module Pione
+  module Lang
+    # ContextParser is a set of parsers for PIONE contexts.
+    module ContextParser
+      include Parslet
+
+      #
+      # structural context
+      #
+      rule(:structural_context_element) { declaration | conditional_branch }
+      rule(:structural_context) {(structural_context_element | empty_line).repeat}
+
+      # +conditional_branch_context+ matches conditional branch contexts.
+      rule(:conditional_branch_context) {structural_context.as(:conditional_branch_context)}
+
+      # +param_context+ matches parameter block contexts.
+      rule(:param_context) {structural_context.as(:param_context)}
+
+      # +rule_condition_context+ matches rule condition contexts.
+      rule(:rule_condition_context) {structural_context.as(:rule_condition_context)}
+
+      # +flow_context+ matches flow contexts.
+      rule(:flow_context) {structural_context.as(:flow_context)}
+
+      # +package_context+ matches package contexts.
+      rule(:package_context) {structural_context.as(:package_context)}
+
+      #
+      # literal context
+      #
+
+      # +literal_context+ matches any character sequences.
+      rule(:literal_context) { (keyword_End.absent? >> any).repeat }
+
+      # +action_conte+ matches action contexts.
+      rule(:action_context) { literal_context.as(:action_context) }
+    end
+  end
+end

data/lib/pione/lang/context-transformer.rb

@@ -0,0 +1,41 @@
+module Pione
+  module Lang
+    # ConditionalBranchTransformer is a transformer for all branches.
+    module ContextTransformer
+      include Util::ParsletTransformerModule
+
+      # Transform +conditional_branch_context+ into Lang::ConditionalBranchContext.
+      rule(:conditional_branch_context => sequence(:elements)) {
+        Lang::ConditionalBranchContext.new(elements)
+      }
+
+      # Transform +param_context+ into Lang::PrameContext.
+      rule(:param_context => sequence(:elements)) {
+        Lang::ParamContext.new(elements)
+      }
+
+      # Transform +rule_condition_context+ into Lang::RuleConditionContext.
+      rule(:rule_condition_context => sequence(:elements)) {
+        Lang::RuleConditionContext.new(elements)
+      }
+
+      # Transform +flow_context+ into Lang::FlowContext.
+      rule(:flow_context => sequence(:elements)) {
+        Lang::FlowContext.new(elements)
+      }
+
+      # Transform +package_context+ into Lang::PackageContext.
+      rule(:package_context => sequence(:elements)) {
+        Lang::PackageContext.new(elements)
+      }
+
+      # Transform +literal_context+ into Lang::LiteralContext.
+      rule(:action_context => simple(:string)) {
+        Lang::ActionContext.new(Util::Indentation.cut(String.new(string))).tap do |context|
+          line, col = string.line_and_column
+          context.set_source_position(package_name, filename, line, col)
+        end
+      }
+    end
+  end
+end