pione 0.2.2 → 0.3.0

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

@@ -0,0 +1,174 @@
+module Pione
+  module Lang
+    # DeclarationParser is a set of parsers for PIONE declaration setences and
+    # blocks.
+    module DeclarationParser
+      include Parslet
+
+      #
+      # outline
+      #
+
+      # SENTENCES is a list of declarative sentences in PIONE language.
+      SENTENCES = [
+        :variable_binding_sentence,
+        :package_binding_sentence,
+        :param_sentence,
+        :rule_binding_sentence,
+        :constituent_rule_sentence,
+        :input_sentence,
+        :output_sentence,
+        :feature_sentence,
+        :constraint_sentence,
+        :annotation_sentence,
+        :expr_sentence
+      ]
+
+      # BLOCKS is a list of declaration blocks in PIONE language.
+      BLOCKS = [
+        :param_block,
+        :flow_rule_block,
+        :action_rule_block,
+        :empty_rule_block
+      ]
+
+      # +declarative_sentence+ match all declarative sentences.
+      rule(:declarative_sentence) {
+        SENTENCES.inject(nil) {|res, elt| res ? res | send(elt) : send(elt)}
+      }
+
+      # +declarative_block+ match all declarative blocks.
+      rule(:declarative_block) {
+        BLOCKS.inject(nil) {|res, elt| res ? res | send(elt) : send(elt)}
+      }
+
+      # +declaration+ match all declarations.
+      rule(:declaration) { declarative_sentence | declarative_block }
+
+      #
+      # sentences
+      #
+
+      # Make a parser for binding sentences.
+      def binding_sentence(declarator, operator, omittable)
+        binding = expr.as(:expr1) >> padded?(operator) >> expr!.as(:expr2)
+
+        if omittable
+          line((declarator.as(:declarator) >> pad).maybe >> binding)
+        else
+          line(declarator.as(:declarator) >> pad >> binding)
+        end
+      end
+
+      # +variable_binding_sentence+ matches variable binding declarations.
+      rule(:variable_binding_sentence) {
+        binding_sentence(keyword_bind, binding_operator!, true).as(:variable_binding_sentence)
+      }
+
+      # +package_binding_sentence+ matches all package binding setences.
+      rule(:package_binding_sentence) {
+        binding_sentence(keyword_package, generating_operator!, false).as(:package_binding_sentence)
+      }
+
+      # +param_sentence+ matches parameter declarations.
+      rule(:param_sentence) {
+        type = (keyword_basic | keyword_advanced).as(:type)
+        with_default = expr.as(:expr1) >> padded?(binding_operator) >> expr!.as(:expr2)
+        without_default = expr.as(:expr1)
+
+        line(((type >> pad).maybe >> keyword_param.as(:declarator) >> pad >> (with_default | without_default)).as(:param_sentence))
+      }
+
+      # +rule_binding_sentence+ matches rule binding declarations.
+      rule(:rule_binding_sentence) {
+        binding_sentence(keyword_rule, binding_operator, false).as(:rule_binding_sentence)
+      }
+
+      # +constituent_sentence+ matches constituent rule declarations.
+      rule(:constituent_rule_sentence) {
+        line(keyword_rule.as(:declarator) >> pad >> expr!.as(:expr)).as(:constituent_rule_sentence)
+      }
+
+      # +input_sentence+ matches input condition declarations.
+      rule(:input_sentence) {
+        line(keyword_input.as(:declarator) >> pad >> expr!.as(:expr)).as(:input_sentence)
+      }
+
+      # +output_sentence+ matches output condition declarations.
+      rule(:output_sentence) {
+        line(keyword_output.as(:declarator) >> pad >> expr!.as(:expr)).as(:output_sentence)
+      }
+
+      # +feature_sentence+ matches feature declarations.
+      rule(:feature_sentence) {
+        line(keyword_feature.as(:declarator) >> pad >> expr!.as(:expr)).as(:feature_sentence)
+      }
+
+      # +constraint_sentence+ matches constraint declarations.
+      rule(:constraint_sentence) {
+        line(keyword_constraint.as(:declarator) >> pad >> expr!.as(:expr)).as(:constraint_sentence)
+      }
+
+      # +annotation_sentence+ matches annotation declarations.
+      rule(:annotation_sentence) {
+        line((dot >> atmark).as(:declarator) >> pad >> expr!.as(:expr)).as(:annotation_sentence)
+      }
+
+      # +expr_sentence+ matches expression declarations(maybe this is ignored in normal contexts).
+      rule(:expr_sentence) {
+        ( line(question.as(:declarator) >> pad? >> expr!.as(:expr)) |
+          line(expr.as(:expr))
+          ).as(:expr_sentence)
+      }
+
+      #
+      # blocks
+      #
+
+      # +param_block+ matches parameter declarations.
+      rule(:param_block) {
+        (param_block_header >> param_context.as(:context) >> param_block_footer!).as(:param_block)
+      }
+
+      # +param_block_header+ matches parameter block headers.
+      rule(:param_block_header) {
+        line((param_block_modifier.as(:type) >> space).maybe >> keyword_Param.as(:declarator))
+      }
+
+      # +param_block_modifier+ matches all parameter block modifiers.
+      rule(:param_block_modifier) { keyword_Basic | keyword_Advanced }
+
+      # +param_block_footer+ matches parameter declaration block footer.
+      rule(:param_block_footer) { line(keyword_End) }
+      rule(:param_block_footer!) { param_block_footer.or_error("it should be parameter block end") }
+
+      # +flow_rule_block+ matches flow rule declarations.
+      rule(:flow_rule_block) {
+        ( rule_header >> rule_condition_context.as(:context1) >>
+          line(keyword_Flow) >> flow_context.as(:context2) >> rule_footer!
+        ).as(:flow_rule_block)
+      }
+
+      # +action_rule_block+ matches action rule declarations.
+      rule(:action_rule_block) {
+        ( rule_header >> rule_condition_context.as(:context1) >>
+          line(keyword_Action) >> action_context.as(:context2) >> rule_footer!
+        ).as(:action_rule_block)
+      }
+
+      # +empty_rule_block+ matches empty rule declarations.
+      rule(:empty_rule_block) {
+        (rule_header >> rule_condition_context.as(:context) >> rule_footer!).as(:empty_rule_block)
+      }
+
+      # +rule_header+ matches rule headers.
+      rule(:rule_header) {
+        line(keyword_Rule.as(:declarator) >> space >> expr!("should be rule name").as(:expr))
+      }
+
+      # +rule_footer+ matches rule end keywords.
+      rule(:rule_footer) { line(keyword_End) }
+      rule(:rule_footer!) { rule_footer.or_error("rule footer not found") }
+    end
+  end
+end

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

@@ -0,0 +1,153 @@
+module Pione
+  module Lang
+    # DeclarationTransformer is a transformer for all declarations.
+    module DeclarationTransformer
+      include Util::ParsletTransformerModule
+
+      #
+      # sentences
+      #
+
+      # Transform +variable_binding_sentence+ into +Lang::VariableBindingDeclaration+.
+      rule(:variable_binding_sentence => subtree(:tree)) {
+        Lang::VariableBindingDeclaration.new(tree[:expr1], tree[:expr2]).tap do |declaration|
+          line, col = (tree[:declarator] || tree[:expr1]).line_and_column
+          declaration.set_source_position(package_name, filename, line, col)
+        end
+      }
+
+      # Transform +package_binding_sentence+ into +Lang::PackageBindingDeclaration+.
+      rule(:package_binding_sentence => subtree(:tree)) {
+        Lang::PackageBindingDeclaration.new(tree[:expr1], tree[:expr2]).tap do |declaration|
+          line, col = tree[:declarator].line_and_column
+          declaration.set_source_position(package_name, filename, line, col)
+        end
+      }
+
+      # Transform +param_sentence+ into +Lang::ParamDeclaration+.
+      rule(:param_sentence => subtree(:tree)) {
+        type = (tree[:type] || "basic").to_sym
+
+        Lang::ParamDeclaration.new(type, tree[:expr1], tree[:expr2]).tap do |declaration|
+          line, col = (tree[:type] || tree[:declarator]).line_and_column
+          declaration.set_source_position(package_name, filename, line, col)
+        end
+      }
+
+      # Transform +rule_binding_sentence+ into +Lang::RuleBindingDeclaration+.
+      rule(:rule_binding_sentence => subtree(:tree)) {
+        Lang::RuleBindingDeclaration.new(tree[:expr1], tree[:expr2]).tap do |declaration|
+          line, col = tree[:declarator].line_and_column
+          declaration.set_source_position(package_name, filename, line, col)
+        end
+      }
+
+      # Transform +constituent_rule_sentence+ into +Lang::ConstituentRuleDeclaration+.
+      rule(:constituent_rule_sentence => subtree(:tree)) {
+        Lang::ConstituentRuleDeclaration.new(tree[:expr]).tap do |declaration|
+          line, col = tree[:declarator].line_and_column
+          declaration.set_source_position(package_name, filename, line, col)
+        end
+      }
+
+      # Transform +:input_sentence+ into +Lang::InputDeclaration+.
+      rule(:input_sentence => subtree(:tree)) {
+        Lang::InputDeclaration.new(tree[:expr]).tap do |declaration|
+          line, col = tree[:declarator].line_and_column
+          declaration.set_source_position(package_name, filename, line, col)
+        end
+      }
+
+      # Transform +output_sentence+ into +Lang::OutputDeclaration+.
+      rule(:output_sentence => subtree(:tree)) {
+        Lang::OutputDeclaration.new(tree[:expr]).tap do |declaration|
+          line, col = tree[:declarator].line_and_column
+          declaration.set_source_position(package_name, filename, line, col)
+        end
+      }
+
+      # Transform +feature_sentence+ into +Lang::FeatureDeclaration+.
+      rule(:feature_sentence => subtree(:tree)) {
+        Lang::FeatureDeclaration.new(tree[:expr]).tap do |declaration|
+          line, col = tree[:declarator].line_and_column
+          declaration.set_source_position(package_name, filename, line, col)
+        end
+      }
+
+      # Transform +constraint_sentence+ into +Lang::ConstraintDeclaration+.
+      rule(:constraint_sentence => subtree(:tree)) {
+        Lang::ConstraintDeclaration.new(tree[:expr]).tap do |declaration|
+          line, col = tree[:declarator].line_and_column
+          declaration.set_source_position(package_name, filename, line, col)
+        end
+      }
+
+      # Transform +annotation_sentence+ into +Lang::AnnotationDeclaration+.
+      rule(:annotation_sentence => subtree(:tree)) {
+        Lang::AnnotationDeclaration.new(tree[:expr]).tap do |declaration|
+          line, col = tree[:declarator].line_and_column
+          declaration.set_source_position(package_name, filename, line, col)
+        end
+      }
+
+      # Transform +expr_sentence+ into +Lang::ExprDeclaration+.
+      rule(:expr_sentence => subtree(:tree)) {
+        Lang::ExprDeclaration.new(tree[:expr]).tap do |declaration|
+          line, col = (tree[:declarator] || tree[:expr]).line_and_column
+          declaration.set_source_position(package_name, filename, line, col)
+        end
+      }
+
+      #
+      # blocks
+      #
+
+      # Transform +param_block+ into +Lang::ParamBlock+.
+      rule(:param_block => subtree(:tree)) {
+        type = (tree[:type] || "basic").to_s.downcase.to_sym
+        context = tree[:context].set(type: type)
+
+        Lang::ParamBlockDeclaration.new(type, context).tap do |declaration|
+          line, col = (tree[:type] || tree[:declarator]).line_and_column
+          declaration.set_source_position(package_name, filename, line, col)
+        end
+      }
+
+      # Transform +flow_rule_block+ into +Lang::FlowRuleDeclaration+.
+      rule(:flow_rule_block => subtree(:tree)) {
+        expr = tree[:expr]
+        condition_context = tree[:context1]
+        flow_context = tree[:context2]
+
+        Lang::FlowRuleDeclaration.new(expr, condition_context, flow_context).tap do |declaration|
+          line, col = tree[:declarator].line_and_column
+          declaration.set_source_position(package_name, filename, line, col)
+        end
+      }
+
+      # Transform +action_rule_block+ into +Lang::ActionRuleDeclaration+.
+      rule(:action_rule_block => subtree(:tree)) {
+        expr = tree[:expr]
+        condition_context = tree[:context1]
+        action_context = tree[:context2]
+
+        Lang::ActionRuleDeclaration.new(expr, condition_context, action_context).tap do |declaration|
+          line, col = tree[:declarator].line_and_column
+          declaration.set_source_position(package_name, filename, line, col)
+        end
+      }
+
+      # Transform +empty_rule_block+ into +Lang::EmptyRuleDeclaration+.
+      rule(:empty_rule_block => subtree(:tree)) {
+        expr = tree[:expr]
+        condition_context = tree[:context]
+
+        Lang::EmptyRuleDeclaration.new(expr, condition_context).tap do |declaration|
+          line, col = tree[:declarator].line_and_column
+          declaration.set_source_position(package_name, filename, line, col)
+        end
+      }
+    end
+  end
+end
+

data/lib/pione/lang/declaration.rb

@@ -0,0 +1,322 @@
+module Pione
+  module Lang
+    # Declaration is a base class for all declarations.
+    class Declaration < StructX
+      include Util::Positionable
+      immutable true
+
+      class << self
+        def inherited(cls)
+          members.each {|member_name| subclass.member(member_name, default: default_values[member_name])}
+          immutable true
+        end
+      end
+
+      def eval!(env)
+        eval(env)
+      end
+
+      private
+
+      # Get reference object. If it has no package id, set current package id in
+      # the environment.
+      def get_reference(env, name, expected)
+        # evaluate the name expression if it has unexpected type
+        # e.g. "$p.var($x) := 1"
+        unless name.is_a?(expected)
+          name = name.eval(env)
+
+          # raise error if it has unexpected type
+          unless name.is_a?(expected)
+            raise StructuralError.new(expected, name.pos)
+          end
+        end
+
+        # set current package id if it has no package id
+        if name.is_a?(Sequence)
+          name.map {|piece| piece.package_id ? piece : piece.set(package_id: env.current_package_id)}
+        else
+          name.package_id ? name : name.set(package_id: env.current_package_id)
+        end
+      end
+
+      # Get the package id.
+      def get_package_id(env, name)
+        if package_id = name.package_id
+          # get package id from the name
+          return package_id
+        else
+          # or current package id in the environment
+          return env.current_package_id
+        end
+      end
+    end
+
+    # VariableBindingDeclaration is a declaration for binding variable to expression.
+    class VariableBindingDeclaration < Declaration
+      member :expr1 # variable name
+      member :expr2 # bound expression
+
+      # Update variable table in the environment with the variable and bound
+      # expression. We expect +expr1+ is a variable or variable generating
+      # expression.
+      def eval(env)
+        var = get_reference(env, expr1, Variable)
+        val = expr2
+
+        # update variable table
+        env.variable_set(var, val)
+      end
+    end
+
+    # PackageBindingDeclaration is a declaration for package binding sentences.
+    class PackageBindingDeclaration < Declaration
+      member :expr1 # variable name
+      member :expr2 # expression for generating new package
+
+      # Update variable table and package table.
+      def eval(env)
+        # variable name
+        var = get_reference(env, expr1, Variable)
+
+        # check the parent package
+        parent_package = expr2.eval(env)
+
+        # evaluate expr2 and get new package instance
+        child_pieces = parent_package.pieces.map do |parent_piece|
+          # definition of parent package
+          parent_definition = env.package_get(parent_piece)
+          # generate new id
+          child_id = Util::PackageID.generate(env, parent_piece.name)
+          # validate parameter set
+          parent_piece.param.pieces.each do |param_piece|
+            param_piece.table.keys do |key|
+              unless parent_definition.param_definition.has_key?(key.name)
+                raise ParamError.new(key.name, parent_piece.package_id)
+              end
+            end
+          end
+          # update package table
+          definition = PackageDefinition.new(
+            package_id: child_id,
+            parent_ids: [parent_piece.package_id],
+            param_definition: parent_definition.param_definition,
+            param: parent_definition.param.merge(parent_piece.param)
+          )
+          # create child piece
+          child_piece = parent_piece.set(package_id: child_id, parent_ids: [parent_piece.package_id])
+          # register the child to package table
+          env.package_set(child_piece, definition)
+          # result
+          child_piece
+        end
+        child_package = PackageExprSequence.of(*child_pieces)
+
+        # update variable table with the result
+        VariableBindingDeclaration.new(var, child_package).eval(env)
+      end
+    end
+
+    # ParamDeclaration is a declaration thae the parameter is neeeded.
+    class ParamDeclaration < Declaration
+      member :type  # basic/advanced
+      member :expr1 # variable name
+      member :expr2 # default expression
+
+      def set_type(new_type)
+        set(type: new_type)
+      end
+
+      # Add the parameter in current rule definition.
+      def eval(env)
+        # get variable
+        var = get_reference(env, expr1, Variable)
+
+        # we don't permit to declare parameters of other packages
+        if not(var.package_id.nil?) and var.package_id != env.current_package_id
+          raise ParamDeclarationError.new(self)
+        end
+
+        # get the value(don't evaluate in this time)
+        default_val = expr2
+
+        begin
+          env.variable_get(var)
+        rescue UnboundError
+          # bind default value
+          env.variable_set(var, default_val)
+        end
+
+        param = ParameterDefinition.new(type, var.name, default_val)
+
+        # select target definition
+        definition = nil
+        if env.current_definition
+          # in rule definition context
+          definition = env.current_definition
+        else
+          # in package context
+          definition = env.package_get(PackageExpr.new(package_id: var.package_id))
+        end
+
+        if definition.param_definition[var.name]
+          raise RebindError.new(var)
+        else
+          definition.param_definition[var.name] = param
+        end
+      end
+    end
+
+    # RuleBindingDeclaration is a declaration for rule binding stentences.
+    class RuleBindingDeclaration < Declaration
+      member :expr1 # new rule name
+      member :expr2 # referent
+
+      # Update rule table with the rule name and reference definition.
+      # e.g. "rule A := B"
+      def eval(env)
+        # rule name
+        refs = get_reference(env, expr1, RuleExprSequence)
+
+        refs.pieces.each do |ref|
+          referents = expr2.eval!(env)
+          referents.pieces.each do |referent|
+            # merge param sets
+            definition = env.rule_get_value(referent)
+            param_sets = definition.param_sets.merge(referent.param_sets)
+            _referent = referent.set(param_sets: param_sets)
+
+            # update rule table
+            env.rule_set(ref, _referent)
+          end
+        end
+      end
+    end
+
+    # ConstituentRuleDeclaration is a declaration for constituent rule sentences.
+    class ConstituentRuleDeclaration < Declaration
+      member :expr
+
+      # Append the constituent rule to the current definition.
+      def eval(env)
+        env.current_definition.rules += expr.eval!(env)
+      end
+    end
+
+    # InputDeclaration is a declaration for input condition sentences.
+    class InputDeclaration < Declaration
+      member :expr
+
+      # Append the input condition to the current definition.
+      def eval(env)
+        env.current_definition.inputs << expr
+      end
+    end
+
+    # OutputDeclaration is a declaration for output condition sentences.
+    class OutputDeclaration < Declaration
+      member :expr
+
+      # Append the output condition to the current definition.
+      def eval(env)
+        env.current_definition.outputs << expr
+      end
+    end
+
+    class FeatureDeclaration < Declaration
+      member :expr
+
+      def eval(env)
+        env.current_definition.features << expr
+      end
+    end
+
+    class ConstraintDeclaration < Declaration
+      member :expr
+
+      def eval(env)
+        env.current_definition.constraints << expr
+      end
+    end
+
+    class AnnotationDeclaration < Declaration
+      member :expr
+
+      def eval(env)
+        env.current_definition.annotations << expr.eval(env)
+      end
+    end
+
+    class ExprDeclaration < Declaration
+      member :expr
+
+      # Return evaluation result of the value.
+      def eval(env)
+        expr.eval(env)
+      end
+    end
+
+    class ParamBlockDeclaration < Declaration
+      member :type
+      member :context
+
+      def eval(env)
+        context.eval(env)
+      end
+    end
+
+    class FlowRuleDeclaration < Declaration
+      member :expr                   # rule name
+      member :rule_condition_context # rule condition context
+      member :flow_context           # flow context
+
+      def eval(env)
+        rules = get_reference(env, expr, RuleExprSequence)
+        rules.pieces.each do |piece|
+          ref = piece.set(package_id: get_package_id(env, piece))
+
+          definition = FlowRuleDefinition.new(
+            rule_condition_context: rule_condition_context,
+            flow_context: flow_context
+          )
+
+          env.rule_set(ref, definition)
+        end
+      end
+    end
+
+    class ActionRuleDeclaration < Declaration
+      member :expr              # rule name
+      member :condition_context # rule condition context
+      member :action_context    # action context
+
+      def eval(env)
+        rules = get_reference(env, expr, RuleExprSequence)
+        rules.pieces.each do |piece|
+          ref = piece.set(package_id: get_package_id(env, piece))
+
+          definition = ActionRuleDefinition.new(
+            rule_condition_context: condition_context,
+            action_context: action_context
+          )
+
+          env.rule_set(ref, definition)
+        end
+      end
+    end
+
+    class EmptyRuleDeclaration < Declaration
+      member :expr              # rule name
+      member :condition_context # rule condition context
+
+      def eval(env)
+        rules = get_reference(env, expr, RuleExprSequence)
+        rules.pieces.each do |piece|
+          ref = piece.set(package_id: get_package_id(env, piece))
+          definition = EmptyRuleDefinition.new(condition_context)
+          env.rule_set(ref, definition)
+        end
+      end
+    end
+  end
+end