pione 0.4.2 → 0.5.0.alpha.1

data/lib/pione/pnml/net-rewriter.rb

@@ -22,11 +22,13 @@ module Pione
       #
       # @param net [PNML::Net]
       #   a net that is a target of this transformation
+      # @param env [Lang::Environment]
+      #   language environment
       # @return [void]
-      def rewrite(net)
+      def rewrite(net, env)
         # find rewriting subjects
         rule, subjects = @rules.inject(nil) do |res, _rule|
-          if res.nil? and _subjects = _rule.find_subjects(net)
+          if res.nil? and _subjects = _rule.find_subjects(net, env)
             [_rule, _subjects]
           else
             res
@@ -35,8 +37,8 @@ module Pione
 
         # rewrite the net with subjects and go next
         if subjects
-          rule.rewrite(net, subjects)
-          rewrite(net)
+          rule.rewrite(net, subjects, env)
+          rewrite(net, env)
         end
       end
     end

data/lib/pione/pnml/output-decomposition-complement.rb

@@ -29,24 +29,26 @@ module Pione
       #
       # @param net [PNML::Net]
       #   rewriting target net
+      # @param env [Lang::Environment]
+      #   language environment
       # @return [Array]
       #   source place and component places
-      def self.find_subjects(net)
+      def self.find_subjects(net, env)
         net.places.each do |place|
           # source place should be empty
-          next unless place.empty_name?
+          next unless Perspective.empty_place?(env, place)
 
           # there should be more than 2 target transitions
           transitions = net.find_all_transitions_by_source_id(place.id)
           next unless transitions.size > 1
-          next unless transitions.all? {|transition| transition.empty_name?}
+          next unless transitions.all? {|transition| Perspective.empty_transition?(env, transition)}
 
           # each transition has only one output named place
           component_places = []
           next unless transitions.all? do |transition|
             _places = net.find_all_places_by_source_id(transition.id)
             component_places.concat(_places)
-            _places.size == 1 and not(_places.first.empty_name?)
+            _places.size == 1 and not(Perspective.empty_place?(env, _places.first))
           end
 
           return [place, component_places]
@@ -61,16 +63,19 @@ module Pione
       #   rewriting target net
       # @param subjects [Array]
       #   source place and component places
+      # @param env [Lang::Environment]
+      #   language environment
       # @return [void]
-      def self.rewrite(net, subjects)
+      def self.rewrite(net, subjects, env)
         place, component_places = subjects
 
         # component places' names
         names = component_places.map do |component_place|
-          Perspective.normalize_data_name(component_place.name)
+          LabelExtractor.extract_data_expr(component_place.name)
         end
 
-        place.name = "%s%s" % [Perspective.modifier(place.name), names.sort.join(" or ")]
+        modifier = Perspective.data_modifier(env, place) || ""
+        place.name = modifier + names.sort.join(" or ")
       end
     end
   end

data/lib/pione/pnml/output-reduction.rb

@@ -19,16 +19,18 @@ module Pione
       #
       # @param net [PNML::Net]
       #   rewriting target net
+      # @param env [Lang::Environment]
+      #   language environment
       # @return [Array]
       #   source place, target transition, and the arc
-      def self.find_subjects(net)
+      def self.find_subjects(net, env)
         net.places.each do |place|
           # source place should be empty
-          next unless Perspective.empty?(place)
+          next unless Perspective.empty_place?(env, place)
 
           # source place should be an output of named transition
           next if net.find_all_transitions_by_target_id(place.id).map do |transition|
-            Perspective.named?(transition)
+            not(Perspective.empty_transition?(env, transition))
           end.empty?
 
           transitions = net.find_all_transitions_by_source_id(place.id)
@@ -40,7 +42,7 @@ module Pione
             # the transtion is connected to only one place at source side
             if net.find_all_places_by_target_id(transition.id).size == 1
               # target transition should be empty
-              next unless Perspective.empty?(transition)
+              next unless Perspective.empty?(env, transition)
 
               return [place, transition, net.find_arc(place.id, transition.id)]
             end
@@ -59,8 +61,12 @@ module Pione
       #
       # @param net [PNML::Net]
       #   rewriting target net
+      # @param subjects [Array]
+      #   source transitions and target place
+      # @param env [Lang::Environment]
+      #   language environment
       # @return [void]
-      def self.rewrite(net, subjects)
+      def self.rewrite(net, subjects, env)
         place, transition, arc = subjects
 
         # remove subjects from the net

data/lib/pione/pnml/output-synchronization-complement.rb

@@ -29,23 +29,25 @@ module Pione
       #
       # @param net [PNML::Net]
       #   rewriting target net
+      # @param env [Lang::Environment]
+      #   language environment
       # @return [Array]
       #   source places and synchronized place
-      def self.find_subjects(net)
+      def self.find_subjects(net, env)
         net.transitions.each do |transition|
           # target transition should be empty
-          next unless transition.empty_name?
+          next unless Perspective.empty_transition?(env, transition)
 
           # the transition should have only one output place
           synchronized_places = net.find_all_places_by_source_id(transition.id).select do |place|
-            Perspective.file?(place)
+            Perspective.data_place?(env, place)
           end
           next unless synchronized_places.size == 1
 
           # collect source places
           source_places = net.find_all_places_by_target_id(transition.id)
           next unless source_places.size > 1
-          next unless source_places.any? {|place| place.empty_name?}
+          next unless source_places.any? {|place| Perspective.empty_place?(env, place)}
 
           # return subjects
           return [source_places, synchronized_places.first]
@@ -60,15 +62,17 @@ module Pione
       #   rewriting target net
       # @param subjects [Array]
       #   source places and synchronized place
+      # @param env [Lang::Environment]
+      #   language environment
       # @return [void]
-      def self.rewrite(net, subjects)
+      def self.rewrite(net, subjects, env)
         source_places, synchronized_place = subjects
 
         # rewrite names of empty source places
         source_places.each do |place|
           # rewrite name only if it is empty
-          if place.empty_name?
-            place.name = synchronized_place.name
+          if Perspective.empty_place?(env, place)
+            place.name = LabelExtractor.extract_data_expr(synchronized_place.name)
           end
         end
       end

data/lib/pione/pnml/parser.rb

@@ -0,0 +1,106 @@
+module Pione
+  module PNML
+    class Parser < Parslet::Parser
+      include Util::ParsletParserExtension
+      include Lang::CommonParser
+      include Lang::LiteralParser
+      include Lang::ExprParser
+      include Lang::ContextParser
+      include Lang::ConditionalBranchParser
+      include Lang::DeclarationParser
+
+      #
+      # symbols and keywords
+      #
+
+      rule(:symbol_net_input_data) { str("<") }
+      rule(:symbol_net_output_data) { str(">") }
+
+      rule(:keyword_then) { str("then") }
+      rule(:keyword_extern) { str("extern") }
+
+      rule(:transition_keyword) {
+        keyword_if         |
+        keyword_else       |
+        keyword_then       |
+        keyword_case       |
+        keyword_when       |
+        keyword_constraint |
+        keyword_extern
+      }
+
+      #
+      # transtion syntax
+      #
+
+      rule(:empty_transition) { space?.as(:tail) }
+
+      rule(:keyword_transition) {
+        space? >> transition_keyword >> space?.as(:tail)
+      }
+
+      rule(:if_transition) {space? >> keyword_if >> space?.as(:tail)}
+      rule(:else_transition) {space? >> keyword_else >> space?.as(:tail)}
+      rule(:then_transition) {space? >> keyword_then >> space?.as(:tail)}
+      rule(:case_transition) {space? >> keyword_case >> space?.as(:tail)}
+      rule(:when_transition) {space? >> keyword_when >> space?.as(:tail)}
+      rule(:constraint_transition) {space? >> keyword_constraint >> space?.as(:tail)}
+
+      rule(:rule_transition) {
+        external_rule_transition | internal_rule_transition
+      }
+
+      rule(:external_rule_transition) {
+        space? >> keyword_extern.as(:modifier) >> space? >>
+        expr.or_error("it should be rule exprssion") >>
+        space?.as(:tail)
+      }
+
+      rule(:internal_rule_transition) {
+        space? >>
+        (keyword_transition >> identifier_tail_character.absent?).absent? >>
+        expr >>
+        space?.as(:tail)
+      }
+
+      #
+      # place syntax
+      #
+
+      rule(:data_modifier) {
+        (symbol_net_input_data | symbol_net_output_data).as(:modifier)
+      }
+
+      rule(:empty_place) {
+        (space? >> data_modifier >> space?.as(:tail)) | space?.as(:tail)
+      }
+
+      rule(:data_place) {
+        (space? >> data_modifier >> expr_place) | expr_place
+      }
+
+      rule(:expr_place) {
+        space? >> expr >> space?.as(:tail)
+      }
+
+      #
+      # others
+      #
+
+      rule(:net_input_symbol) {
+        space? >> symbol_net_input_data >> space?
+      }
+
+      rule(:net_output_symbol) {
+        space? >> symbol_net_output_data >> space?
+      }
+
+      rule(:data_priority) {
+        space? >>
+        expr >>
+        space_char.repeat(0) >>
+        str("#") >> space? >> digit.repeat(1).as(:priority) >> space?
+      }
+    end
+  end
+end

data/lib/pione/pnml/pione-model.rb

@@ -2,168 +2,490 @@ module Pione
   module PNML
     # `Perspective` is a meta class for PIONE's concepts overlayed in PNML.
     class Perspective
-      # Eliminate comments from the string. This implementation is temporary, we
-      # should fix this.
-      def self.eliminate_comment(str)
-        # FIXME
-        str.sub(/#.*$/, "")
-      end
+      TRANSFORMER_OPT = {package_name: "", editor: "", tag: "", filename: ""}
+
+      class << self
+        # Return true if the node is empty.
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   the node
+        # @return [Boolean]
+        #   true if the node is empty
+        def empty?(env, node)
+          empty_place?(env, node) or empty_transition?(env, node)
+        end
 
-      # Return true if the node is empty in PIONE model.
-      #
-      # @return [Boolean]
-      #   true if the node is empty
-      def self.empty?(node)
-        # node should be a place or transition
-        return false unless node.is_a?(Place) or node.is_a?(Transition)
+        # Return true if the node is an empty place.
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   the node
+        # @return [Boolean]
+        #   true if the node is an empty place
+        def empty_place?(env, node)
+          match_place_parser?(env, node, :empty_place)
+        end
 
-        return true if node.name.nil?
-        return true if /^[<>]?\s*$/.match(eliminate_comment(node.name.strip))
-      end
+        # Return true if the node is an empty transition.
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   the node
+        # @return [Boolean]
+        #   true if the node is an empty transition
+        def empty_transition?(env, node)
+          match_transition_parser?(env, node, :empty_transition)
+        end
 
-      # Return true if the node is named in PIONE model.
-      #
-      # @return [Boolean]
-      #   true if the node is named
-      def self.named?(node)
-        not(empty?(node))
-      end
+        # Return true if the node is an expression place.
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   the node
+        # @return [Boolean]
+        #   true if the node is an exression place
+        def expr_place?(env, node)
+          match_place_parser?(node, :expr_place)
+        end
 
-      # Return true if the node is a file in PIONE model.
-      #
-      # @return [Boolean]
-      #    true if the node is a file
-      def self.file?(node)
-        # files should be represented as a place
-        return false unless node.is_a?(Place)
-        return false if node.name.nil?
+        # Return true if the node is a data place.
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   the node
+        # @return [Boolean]
+        #    true if the node is a data place
+        def data_place?(env, node)
+          match_place_parser_with_type?(env, node, :data_place, :expr, Lang::TypeDataExpr)
+        end
 
-        # normalize
-        name = node.name.strip
-        if name.size > 0 and "<>".include?(name[0])
-          name = name.sub(/[<>]/, "")
+        # Return true if the node is a net input data place.
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   the node
+        # @return [Boolean]
+        #   true if the node is a net input data place
+        def net_input_data_place?(env, node)
+          if data_place?(env, node)
+            return net_input_data_symbol?(data_modifier(env, node))
+          else
+            return false
+          end
         end
 
-        # test
-        return (name.size > 0 and name[0] == "'")
-      end
+        # Return true if the node is a net output data place.
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   the node
+        # @return [Boolean]
+        #   true if the node is a net output data place
+        def net_output_data_place?(env, node)
+          if data_place?(env, node)
+            return net_output_data_symbol?(data_modifier(node))
+          else
+            return false
+          end
+        end
 
-      # Return true if the node is a ticket in PIONE model.
-      #
-      # @return [Boolean]
-      #   true if the node is a ticket
-      def self.ticket?(node)
-        # tickets should be represented as a place
-        return false unless node.is_a?(Place)
+        # Return true if the node is a parameter.
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   the node
+        # @return [Boolean]
+        #   true if the node is a parameter
+        def param_place?(env, node)
+          match_place_parser_with_type?(env, node, :expr_place, :expr, Lang::TypeParameterSet)
+        end
 
-        # try parsing as a ticket expression
-        Lang::Parser.ticket_expr.parse(node.name)
+        # Return true if the node is a parameter sentence transition.
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   PNML's node
+        # @return [Boolean]
+        #   true if the node is a parameter sentence transition
+        def param_transition?(env, node)
+          match_transition_parser?(env, node, :param_sentence)
+        end
 
-        # the node is a ticket
-        return true
-      rescue Parslet::ParseFailed => e
-        # the node is not a ticket
-        return false
-      end
+        # Evaluate the node as a parameter sentence.
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   PNML's node
+        # @return [Object]
+        #   evaluated result
+        def eval_param_sentence(env, node)
+          eval_transition(env, node, :param_sentence, :param_sentence)
+        end
 
-      # Return true if the node is a parameter in PIONE model.
-      #
-      # @return [Boolean]
-      #   true if the node is a parameter
-      def self.param?(node)
-        # parameter node should be represented as a place
-        return false unless node.is_a?(Place)
-
-        # parameter node should be parsed as param sentence
-        begin
-          Lang::DocumentParser.new.param_sentence.parse(name)
-          return true
-        rescue
-          return false
+        # Return true if the node is a ticket place.
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   the node
+        # @return [Boolean]
+        #   true if the node is a ticket place
+        def ticket_place?(env, node)
+          match_place_parser_with_type?(env, node, :expr_place, :expr, Lang::TypeTicketExpr)
         end
-      end
 
-      # Return true if the node is a rule.
-      #
-      # @param node [PNML::Node]
-      #   the node
-      # @return [Boolean]
-      #   true if the node is a rule.
-      def self.rule?(node)
-        return false unless node.is_a?(Transition)
-        return false unless not(node.name.nil?)
+        # Return true if the node is a feature place.
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   the node
+        # @return [Boolean]
+        #   true if the node is a feature place
+        def feature_place?(env, node)
+          match_place_parser_with_type?(env, node, :expr_place, :expr, Lang::TypeFeature)
+        end
 
-        name = node.name.strip
+        # Return true if the node is a feature transition.
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   the node
+        # @return [Boolean]
+        #   true if the node is a feature transition
+        def feature_transition?(env, node)
+          match_place_parser?(env, node, :feature_sentence)
+        end
 
-        # keywords
-        if ["if", "else", "then"].include?(name)
-          return false
+        # Return true if the node is a variable binding transition.
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   the node
+        # @return [Boolean]
+        #   true if the node is a variable binding transition
+        def variable_binding_transition?(env, node)
+          match_transition_parser?(env, node, :variable_binding_sentence)
         end
 
-        return name.size > 0
-      end
+        # Return true if the node is a rule.
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   the node
+        # @return [Boolean]
+        #   true if the node is a rule.
+        def rule_transition?(env, node)
+          match_transition_parser?(env, node, :rule_transition)
+        end
 
-      # Return ture if the node is a flow rule.
-      def self.flow_rule?(node)
-        rule?(node) and node.name.strip.start_with?("&")
-      end
+        # Return ture if the node is an internal rule.
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param [PNML::Node] node
+        #   PNML node
+        # @return [Boolean]
+        #   true if the node is an internal rule
+        def internal_rule_transition?(env, node)
+          match_transition_parser?(env, node, :internal_rule_transition)
+        end
 
-      def self.action_rule?(node)
-        rule?(node) and not(flow_rule?(node))
-      end
+        # Return ture if the node is an external rule.
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param [PNML::Node] node
+        #   PNML node
+        # @return [Boolean]
+        #   true if the node is an external rule
+        def external_rule_transition?(env, node)
+          match_transition_parser?(env, node, :external_rule_transition)
+        end
 
-      def self.normalize_data_name(name)
-        return nil if name.nil?
+        # Return the modifier of node name.
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   the node
+        # @return [String]
+        #   modifier or nil
+        def data_modifier(env, node)
+          if node.kind_of?(Place) and not(node.name.nil?)
+            begin
+              parsed = Parser.new.data_place.parse(node.name)
+              if parsed.kind_of?(Hash)
+                return parsed[:modifier].to_s
+              end
+            rescue Parslet::ParseFailed
+              begin
+                parsed = Parser.new.empty_place.parse(node.name)
+                if parsed.kind_of?(Hash)
+                  return parsed[:modifier].to_s
+                end
+              rescue Parslet::ParseFailed
+              end
+            end
+          end
+          return nil
+        end
 
-        name = name.strip
-        name = remove_comment(name)
-        if name.size > 0 and name[0] == "<" or name[0] == ">"
-          name[1..-1].strip
-        else
-          name
+        # Return true if the node is a transition with keyword.
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   PNML's node
+        # @return [Boolean]
+        #   true if the node is a transition with keyword
+        def keyword_transition?(env, node)
+          match_transition_parser?(env, node, :keyword_transition)
         end
-      end
 
-      def self.compact(name)
-        remove_comment(name)
-      end
+        # Return true if the node is a transition with keyword "if".
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   PNML's node
+        # @return [Boolean]
+        #   true if the node is a transition with keyword "if"
+        def if_transition?(env, node)
+          match_transition_parser?(env, node, :if_transition)
+        end
 
-      def self.remove_comment(name)
-        name.sub(/#\s*$/, "").strip
-      end
+        # Return true if the node is a transition with keyword "then".
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   PNML's node
+        # @return [Boolean]
+        #   true if the node is a transition with keyword "then"
+        def then_transition?(env, node)
+          match_transition_parser?(env, node, :then_transition)
+        end
 
-      # Return true if the node is a net's input.
-      #
-      # @param node [PNML::Node]
-      #   the node
-      # @return [Boolean]
-      #   true if the node is a net's input.
-      def self.net_input?(node)
-        node.name and compact(node.name)[0] == "<"
-      end
+        # Return true if the node is a transition with keyword "else".
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   PNML's node
+        # @return [Boolean]
+        #   true if the node is a transition with keyword "else"
+        def else_transition?(env, node)
+          match_transition_parser?(env, node, :else_transition)
+        end
 
-      # Return true if the node is a net's output.
-      #
-      # @param node [PNML::Node]
-      #   the node
-      # @return [Boolean]
-      #   true if the node is a net's output.
-      def self.net_output?(node)
-        node.name and compact(node.name)[0] == ">"
-      end
+        # Return true if the node is a transition with keyword "case".
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   PNML's node
+        # @return [Boolean]
+        #   true if the node is a transition with keyword "case"
+        def case_transition?(env, node)
+          match_transition_parser?(env, node, :case_transition)
+        end
 
-      def self.modifier(name)
-        if name.size > 0 and name.strip[0] == "<"
-          return "<"
+        # Return true if the node is a transition with keyword "when".
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   PNML's node
+        # @return [Boolean]
+        #   true if the node is a transition with keyword "when"
+        def when_transition?(env, node)
+          match_transition_parser?(env, node, :when_transition)
         end
-        if name.size > 0 and name.strip[0] == ">"
-          return ">"
+
+        # Return true if the node is a transition with keyword "constraint".
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   PNML's node
+        # @return [Boolean]
+        #   true if the node is a transition with keyword "constraint"
+        def constraint_transition?(env, node)
+          match_transition_parser?(env, node, :constraint_transition)
         end
-        return ""
-      end
 
-      private
+        private
+
+        # Return true if the string is net input data symbol.
+        #
+        # @param [String]
+        #   string
+        # @return [Boolean]
+        #   true if the string is net input data symbol
+        def net_input_data_symbol?(str)
+          return false if str.nil?
+
+          Parser.new.net_input_symbol.parse(str)
+          return true
+        rescue Parslet::ParseFailed
+          return false
+        end
+
+        # Return true if the string is net output data symbol.
+        #
+        # @param [String]
+        #   string
+        # @return [Boolean]
+        #   true if the string is net output data symbol
+        def net_output_data_symbol?(str)
+          return false if str.nil?
+
+          Parser.new.net_output_symbol.parse(str)
+          return true
+        rescue Parslet::ParseFailed
+          return false
+        end
+
+        # Return true if the node matches the place parser.
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   PNML's node
+        # @param parser_name [String]
+        #   place parser name
+        # @return [Boolean]
+        #   true if the node is the place parser
+        def parse_place(env, node, parser_name)
+          if node.kind_of?(Place) and not(node.name.nil?)
+            begin
+              return Parser.new.send(parser_name).parse(node.name)
+            rescue Parslet::ParseFailed
+            end
+          end
+        end
+
+        # Return true if the node matches the place parser.
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   PNML's node
+        # @param parser_name [String]
+        #   place parser name
+        # @return [Boolean]
+        #   true if the node is the place parser
+        def match_place_parser?(env, node, parser_name)
+          parsed = parse_place(env, node, parser_name)
+          if not(parsed.nil?)
+            if block_given?
+              return yield parsed
+            else
+              return true
+            end
+          else
+            return false
+          end
+        end
+
+        # Return true if the node matches the place parser and expected type.
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   PNML's node
+        # @param parser_name [String]
+        #   place parser name
+        # @param target_name [Symbol]
+        #   target name that has expected type
+        # @param expected_type [Pione::Lang::Type]
+        #   expected PIONE type
+        # @return [Boolean]
+        #   true if the node is the place parser
+        def match_place_parser_with_type?(env, node, parser_name, target_name, expected_type)
+          parsed = parse_place(env, node, parser_name)
+          if parsed and parsed[target_name]
+            expr = Lang::DocumentTransformer.new.apply(parsed[target_name], TRANSFORMER_OPT)
+            return expr.pione_type(env) == expected_type
+          else
+            return false
+          end
+        end
+
+        # Return true if the node matches the transition parser.
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   PNML's node
+        # @param parser_name [Symbol]
+        #   place parser name
+        # @return [Boolean]
+        #   true if the node is the transition parser
+        def parse_transition(env, node, parser_name)
+          if node.kind_of?(Transition) and not(node.name.nil?)
+            begin
+              return Parser.new.send(parser_name).parse(node.name)
+            rescue Parslet::ParseFailed
+            end
+          end
+        end
+
+        # Return true if the node matches the transition parser.
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   PNML's node
+        # @param parser_name [Symbol]
+        #   transition parser name
+        # @return [Boolean]
+        #   true if the node is the keyword
+        def match_transition_parser?(env, node, parser_name)
+          not(parse_transition(env, node, parser_name).nil?)
+        end
+
+        # Evaluate the transition and return the result.
+        #
+        # @param env [Lang::Environment]
+        #   language environment
+        # @param node [PNML::Node]
+        #   PNML's node
+        # @param parser_name [Symbol]
+        #   place parser name
+        # @param target_name [Symbol]
+        #   target name that has expected type
+        # @param expected_type [Pione::Lang::Type]
+        #   expected PIONE type
+        # @return [Boolean]
+        #   true if the node is the place parser
+        def eval_transition(env, node, parser_name, target_name)
+          parsed = parse_transition(node)
+          if parsed and parsed[target_name]
+            return Lang::DocumentTransformer.new.apply(parsed[target_name], TRANSFORMER_OPT)
+          else
+            return nil
+          end
+        end
+      end
+    end
 
+    class PioneModel
       # Return an indented version of the string. Indentation size is calculated
       # by the optional argument `:level`. If the level is zero, return the
       # string as is.
@@ -178,8 +500,8 @@ module Pione
       end
     end
 
-    # `ConstituentRule` is a class represents PIONE's constituent rule.
-    class ConstituentRule < Perspective
+    # ConstituentRule is a class represents PIONE's constituent rule.
+    class ConstituentRule < PioneModel
       attr_reader :type
       attr_reader :name
       attr_reader :params
@@ -204,69 +526,46 @@ module Pione
 
       private
 
-      # Return a string form of PIONE's rule expression.
+      # Return a string of rule expression.
+      #
+      # @return [String]
+      #   a string of rule expression
       def textize_rule_expr
         [@name, textize_params].compact.join(" ")
       end
 
-      # Return a string form of PIONE's parameter set.
+      # Return a string of parameter set.
+      #
+      # @return [String]
+      #   a string of parameter set
       def textize_params
         unless @params.empty?
-          "{%s}" % [@params.map{|param| "%s: $%s" % [param.name, param.name]}.join(", ")]
+          @params.inject(Param.new){|res, param| res + param}.as_expr
         end
       end
     end
 
     # `DataCondition` is a class represents PIONE's input and output data condition.
-    class DataCondition < Perspective
+    class Data < PioneModel
       attr_reader :data_expr
       attr_accessor :input_distribution
       attr_accessor :output_distribution
-      attr_accessor :input_priority
-      attr_accessor :output_priority
+      attr_accessor :priority
       attr_accessor :input_nonexistable
       attr_accessor :output_nonexistable
       attr_accessor :output_for_this_flow
 
-      # @param data_expr [String]
+      # @param nod [PNML::Node]
       #   data expression as a PIONE's expression string
-      # @param attr [Hash]
-      #   various attributes for the data expression
-      # @option attr [Symbol] :input_distribution
-      #   input distribution type of either `:each` or `:all`
-      # @option attr [Symbol] :output_distribution
-      #   output distribution type of either `:each` or `:all`
-      # @option attr [Integer] :input_priority
-      #   priority of this input condition
-      # @option attr [Integer] :output_priority
-      #   priority of this output condition
-      # @option attr [Boolean] :output_for_this_flow
-      #   flag for this flow's output
-      def initialize(data_expr, attr={})
-        @data_expr = data_expr
-        @input_distribution = attr[:input_distribution]
-        @output_distribution = attr[:output_distribution]
-        @input_priority = attr[:input_priority] || 1
-        @output_priority = attr[:output_priority] || 1
-        @input_nonexistable = attr[:input_nonexistable]
-        @output_nonexistable = attr[:output_nonexistable]
-        @output_for_this_flow = attr[:output_for_this_flow]
-      end
-
-      # Return a declaration string of the data expression as input condition.
-      def as_input_declaration(option={})
-        indent("input %s" % textize_data_expr(:input), option)
-      end
-
-      # Return a declaration string of the data expression as output condition.
-      def as_output_declaration(option={})
-        indent("output %s" % textize_data_expr(:output), option)
+      def initialize(node)
+        @name = LabelExtractor.extract_data_expr(node.name)
+        @priority = LabelExtractor.extract_priority(node.name)
       end
 
       private
 
       def textize_data_expr(type)
-        data_expr = "%s" % @data_expr
+        data_expr = "%s" % @name
         if (type == :input and @input_nonexistable) or (type == :output and @output_nonexistable)
           data_expr = data_expr + " or null"
         end
@@ -280,28 +579,105 @@ module Pione
       end
     end
 
-    # `Param` is a class represents PIONE's paramter declaration.
-    class Param < Perspective
+    class InputData < Data
+      # Return a declaration string of the data expression as input condition.
+      def as_declaration(option={})
+        indent("input %s" % textize_data_expr(:input), option)
+      end
+    end
+
+    class OutputData < Data
+      # Return a declaration string of the data expression as output condition.
+      def as_declaration(option={})
+        indent("output %s" % textize_data_expr(:output), option)
+      end
+    end
+
+    # Param is a class represents PIONE's paramter set.
+    class Param < PioneModel
+      # Create a parameter from the parameter set node.
+      #
+      # @param node [PNML::Node]
+      #   parameter set node
+      # @return [Param]
+      #   parameter
+      def self.set_of(node)
+        new(LabelExtractor.extract_data_from_param_set(node.name))
+      end
+
+      # Create a parameter from the parameter sentence node.
+      #
+      # @param node [PNML::Node]
+      #   parameter sentence node
+      # @return [Param]
+      #   parameter
+      def self.sentence_of(node)
+        new(LabelExtractor.extract_data_from_param_sentence(node.name))
+      end
+
+      attr_reader :data
+
+      # @param data [Hash]
+      #   param set data
+      def initialize(data={})
+        @data = data
+      end
+
+      def as_expr
+        @data.map do |var, expr|
+          "%s: %s" % [var, expr]
+        end.join(", ").tap {|x| return "{%s}" % x}
+      end
+
+      def as_declarations(option={})
+        @data.map do |var, expr|
+          indent("param $%s := %s" % [var, expr], option)
+        end
+      end
+
+      def +(other)
+        self.class.new(@data.merge(other.data))
+      end
+    end
+
+    # Constraint represents a PIONE's constraint declaration.
+    class Constraint < PioneModel
+      attr_reader :expr
+
+      def initialize(expr)
+        @expr = expr
+      end
+
+      def as_declaration(option={})
+        indent("constraint " + @expr, option)
+      end
+    end
+
+    # Ticket represents a PIONE's ticket declaration.
+    class Ticket < PioneModel
       attr_reader :name
-      attr_reader :default_expr
 
-      # @param name [String]
-      #   parameter name, note that this name doesn't include heading `$`
-      # @param default expr [String]
-      #   default value expression
-      def initialize(name, default_expr)
+      def initialize(name)
         @name = name
-        @default_expr = default_expr
+      end
+    end
+
+    # Feature represents a feature declaration in PIONE.
+    class Feature < PioneModel
+      attr_reader :expr
+
+      def initialize(expr)
+        @expr = expr
       end
 
       def as_declaration(option={})
-        indent("param $%s := %s" % [@name, @default_expr], option)
+        indent("feature " + @expr, option)
       end
     end
 
     # ConditionalBranch is a class represents PIONE's conditional branch
     # declaration.
-    class ConditionalBranch < Perspective
+    class ConditionalBranch < PioneModel
       attr_reader :condition
       attr_reader :table
 
@@ -315,21 +691,22 @@ module Pione
         case @type
         when :"if"
           branch_then = @table[:then].map do |rule|
-            "  rule %s" % Perspective.normalize_data_name(rule.name)
+            rule.as_declaration(option.merge(level: option[:level] + 1))
           end.join("\n")
 
           if @table[:else].empty?
             indent(Util::Indentation.cut(TEMPLATE_IF) % [@condition, branch_then], option)
           else
             branch_else = @table[:else].map do |rule|
-              "  rule %s" % Perspective.normalize_data_name(rule.name)
+              rule.as_declaration(option.merge(level: option[:level] + 1))
             end.join("\n")
             indent(Util::Indentation.cut(TEMPLATE_IF_ELSE) % [@condition, branch_then, branch_else], option)
           end
         when :"case"
-          branches = @table.each_with_object([]) do |(val, rules), list|
-            list << ((val == :else) ? "else" : "when %s" % val)
-            list.concat(rules.map{|rule| "  rule %s" % rule.name})
+          branches = @table.each_with_object([]) do |(val, rules), lines|
+            lines << ((val == :else) ? "else" : "when %s" % val)
+            level = (option[:level] || 0) + 1
+            lines.concat(rules.map{|rule| rule.as_declaration(option.merge(level: level))})
           end.join("\n")
           indent(Util::Indentation.cut(TEMPLATE_CASE) % [@condition, branches], option)
         end
@@ -356,22 +733,34 @@ module Pione
       TXT
     end
 
-    class RuleDefinition < Perspective
-      attr_accessor :name
+    class RuleDefinition < PioneModel
       attr_accessor :type
       attr_accessor :inputs
       attr_accessor :outputs
       attr_accessor :params
+      attr_accessor :constraints
+      attr_accessor :features
+      attr_accessor :source_tickets
+      attr_accessor :target_tickets
       attr_accessor :conditions
+      attr_accessor :variable_bindings
       attr_accessor :flow_elements
       attr_accessor :action_content
 
-      def initialize(name, type, option={})
+      def initialize(name, type, is_external, net_name, index, option={})
         @name = name
         @type = type
+        @is_external = is_external
+        @net_name = net_name
+        @index = index
         @inputs = option[:inputs] || []
         @outputs = option[:outputs] || []
         @params = option[:params] || []
+        @constraints = option[:constraints] || []
+        @features = option[:features] || []
+        @source_tickets = option[:source_tickets] || []
+        @target_tickets = option[:target_tickets] || []
+        @variable_bindings = option[:variable_bindings] || []
         @conditions = option[:conditions] || []
         @flow_elements = option[:flow_elements] || []
         @action_content = nil
@@ -385,70 +774,136 @@ module Pione
         @type == :action
       end
 
-      def textize
-        if flow?
-          template = Util::Indentation.cut(FLOW_RULE_TEMPLATE)
-        else
-          if @action_content
-            template = Util::Indentation.cut(LITERATE_ACTION_RULE_TEMPLATE)
+      def external?
+        @is_external
+      end
+
+      def name
+        external? ? generate_wrapper_name(@name) : @name
+      end
+
+      # Return the declaration form string.
+      def as_declaration(option={})
+        expr_source_tickets =
+          if @source_tickets.size > 0
+            "(%s) ==> " % @source_tickets.map {|ticket| "%s" % ticket.name}.join(" | ")
+          else
+            ""
+          end
+        expr_target_tickets =
+          if @target_tickets.size > 0
+            " ==> (%s)" % @target_tickets.map {|ticket| "%s" % ticket.name}.join(" | ")
+          else
+            ""
+          end
+        "rule %s%s%s" % [expr_source_tickets, name, expr_target_tickets]
+      end
+
+      # Make rule conditions.
+      #
+      # @return [Array<String>]
+      #   rule condition lines
+      def rule_conditions
+        conditions = []
+        sort_data_list(@inputs).each do |input|
+          conditions << input.as_declaration
+        end
+        sort_data_list(@outputs).each do |output|
+          conditions << output.as_declaration
+        end
+        @params.each do |param|
+          conditions += param.as_declarations
+        end
+        @constraints.each do |constraint|
+          conditions << constraint.as_declaration
+        end
+        @features.each do |feature|
+          conditions << feature.as_declaration
+        end
+        conditions
+      end
+
+      def sort_data_list(data_list)
+        data_list.sort do |a, b|
+          priority_a = a.priority
+          priority_b = b.priority
+
+          if a.priority and b.priority
+            a.priority <=> b.priority
+          elsif a.priority
+            1
+          elsif b.priority
+            -1
           else
-            template = Util::Indentation.cut(ACTION_RULE_TEMPLATE)
+            0
           end
         end
+      end
+
+      def textize
         ERB.new(template, nil, "-").result(binding)
       end
 
+      def template
+        if external?
+          return Util::Indentation.cut(WRAPPER_TEMPLATE)
+        end
+
+        if flow?
+          return Util::Indentation.cut(FLOW_RULE_TEMPLATE)
+        end
+
+        if @action_content
+          return Util::Indentation.cut(LITERATE_ACTION_RULE_TEMPLATE)
+        else
+          return Util::Indentation.cut(ACTION_RULE_TEMPLATE)
+        end
+      end
+
+      # Generate a name for wrapper rule.
+      def generate_wrapper_name(name)
+        "__%s_%s_%s__" % [@net_name, @name, @index]
+      end
+
       FLOW_RULE_TEMPLATE = <<-RULE
-        Rule <%= @name %>
-          <%- @inputs.each do |input| -%>
-          input <%= input %>
-          <%- end -%>
-          <%- @outputs.each do |output| -%>
-          output <%= output %>
-          <%- end -%>
-          <%- @params.each do |param| -%>
-          <%= param.as_declaration %>
+        Rule <%= name %>
+          <%- rule_conditions.each do |condition| -%>
+          <%=   condition %>
           <%- end -%>
         Flow
           <%- @flow_elements.each do |element| -%>
-          <%- if element.is_a?(RuleDefinition) -%>
-          rule <%= element.name %>
-          <%- else -%>
-        <%= element.as_declaration(level: 1) %>
-          <%- end -%>
+          <%=   element.as_declaration(level: 1) %>
           <%- end -%>
         End
       RULE
 
       ACTION_RULE_TEMPLATE = <<-RULE
-        Rule <%= @name %>
-          <%- @inputs.each do |input| -%>
-          input <%= input %>
-          <%- end -%>
-          <%- @outputs.each do |output| -%>
-          output (<%= output %>).touch
-          <%- end -%>
-          <%- @params.each do |param| -%>
-          <%= param.as_declaration %>
+        Rule <%= name %>
+          <%- rule_conditions.each do |condition| -%>
+          <%=   condition %>
           <%- end -%>
         End
       RULE
 
       LITERATE_ACTION_RULE_TEMPLATE = <<-RULE
-        Rule <%= @name %>
-          <%- @inputs.each do |input| -%>
-          input <%= input %>
-          <%- end -%>
-          <%- @outputs.each do |output| -%>
-          output <%= output %>
-          <%- end -%>
-          <%- @params.each do |param| -%>
-          <%= param.as_declaration %>
+        Rule <%= name %>
+          <%- rule_conditions.each do |condition| -%>
+          <%=   condition %>
           <%- end -%>
         Action
         <%= Util::Indentation.indent(@action_content, 2) -%>
         End
       RULE
+
+      WRAPPER_TEMPLATE = <<-RULE
+        Rule <%= name %>
+          <%- rule_conditions.each do |condition| -%>
+          <%=   condition %>
+          <%- end -%>
+        Flow
+          rule <%= @name %>
+        End
+      RULE
     end
   end
 end