bcdice 3.0.0.pre.alpha.1 → 3.0.0.pre.alpha.2

data/lib/bcdice/common_command.rb

@@ -3,6 +3,7 @@ require "bcdice/common_command/barabara_dice"
 require "bcdice/common_command/calc"
 require "bcdice/common_command/choice"
 require "bcdice/common_command/d66_dice"
+require "bcdice/common_command/repeat"
 require "bcdice/common_command/reroll_dice"
 require "bcdice/common_command/upper_dice"
 require "bcdice/common_command/version"
@@ -15,6 +16,7 @@ module BCDice
       Calc,
       Choice,
       D66Dice,
+      Repeat,
       RerollDice,
       UpperDice,
       Version,

data/lib/bcdice/common_command/add_dice.rb

@@ -4,50 +4,14 @@ require "bcdice/common_command/add_dice/randomizer"
 
 module BCDice
   module CommonCommand
-    class AddDice
+    module AddDice
       PREFIX_PATTERN = /[\+\-\dD\(\[]+/.freeze
 
-      def initialize(command, randomizer, game_system)
-        @command = command
-        @bcdice = randomizer
-        @diceBot = game_system
-
-        @dice_list = []
-        @is_secret = false
-      end
-
-      def secret?
-        @is_secret
-      end
-
-      def eval()
-        parser = Parser.new(@command)
-
-        command = parser.parse()
-        if parser.error?
-          return nil
+      class << self
+        def eval(command, game_system, randomizer)
+          cmd = Parser.parse(command)
+          cmd&.eval(game_system, randomizer)
         end
-
-        randomizer = Randomizer.new(@bcdice, @diceBot, command.cmp_op)
-        total = command.lhs.eval(randomizer)
-
-        output =
-          if randomizer.dice_list.size <= 1 && command.lhs.is_a?(Node::DiceRoll)
-            "(#{command}) ＞ #{total}"
-          else
-            "(#{command}) ＞ #{command.lhs.output} ＞ #{total}"
-          end
-
-        dice_list = randomizer.dice_list
-
-        if command.cmp_op
-          dice_total = dice_list.inject(&:+)
-          output += @diceBot.check_result(total, dice_total, dice_list, randomizer.sides, command.cmp_op, command.rhs)
-        end
-
-        @is_secret = parser.secret?
-
-        return output
       end
     end
   end

data/lib/bcdice/common_command/add_dice/node.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require "singleton"
+
 module BCDice
   module CommonCommand
-    class AddDice
+    module AddDice
       # 加算ロールの構文解析木のノードを格納するモジュール
       module Node
         # 加算ロールコマンドのノード。
@@ -24,7 +26,8 @@ module BCDice
           # @param [Object] lhs 左辺のノード
           # @param [Symbol] cmp_op 比較演算子
           # @param [Integer, String] rhs 右辺のノード
-          def initialize(lhs, cmp_op, rhs)
+          def initialize(secret, lhs, cmp_op = nil, rhs = nil)
+            @secret = secret
             @lhs = lhs
             @cmp_op = cmp_op
             @rhs = rhs
@@ -33,19 +36,48 @@ module BCDice
           # 文字列に変換する
           # @return [String]
           def to_s
-            @lhs.to_s + cmp_op_text + @rhs.to_s
+            @lhs.to_s + cmp_op_text + @rhs&.eval(nil).to_s
           end
 
           # ノードのS式を返す
           # @return [String]
           def s_exp
             if @cmp_op
-              "(Command (#{@cmp_op} #{@lhs.s_exp} #{@rhs}))"
+              "(Command (#{@cmp_op} #{@lhs.s_exp} #{@rhs.s_exp}))"
             else
               "(Command #{@lhs.s_exp})"
             end
           end
 
+          def eval(game_system, randomizer)
+            randomizer = Randomizer.new(randomizer, game_system)
+            total = @lhs.eval(randomizer)
+
+            interrim_expr =
+              unless randomizer.rand_results.size <= 1 && @lhs.is_a?(Node::DiceRoll)
+                @lhs.output
+              end
+
+            result =
+              if @cmp_op
+                rhs = @rhs.eval(nil)
+                game_system.check_result(total, randomizer.rand_results, @cmp_op, rhs)
+              end
+            result ||= Result.new
+
+            sequence = [
+              "(#{self})",
+              interrim_expr,
+              total,
+              result&.text
+            ].compact
+
+            result.tap do |r|
+              r.secret = @secret
+              r.text = sequence.join(" ＞ ")
+            end
+          end
+
           private
 
           # メッセージ中で比較演算子をどのように表示するかを返す
@@ -62,6 +94,25 @@ module BCDice
           end
         end
 
+        class UndecidedTarget
+          include Singleton
+
+          def eval(_randomizer)
+            "?"
+          end
+
+          def include_dice?
+            false
+          end
+
+          def to_s
+            "?"
+          end
+
+          alias output to_s
+          alias s_exp to_s
+        end
+
         # 二項演算子のノード
         class BinaryOp
           # ノードを初期化する
@@ -87,6 +138,11 @@ module BCDice
             return calc(lhs, rhs)
           end
 
+          # @return [Boolean]
+          def include_dice?
+            @lhs.include_dice? || @rhs.include_dice?
+          end
+
           # 文字列に変換する
           # @return [String]
           def to_s
@@ -258,6 +314,11 @@ module BCDice
             -@body.eval(randomizer)
           end
 
+          # @return [Boolean]
+          def include_dice?
+            @body.include_dice?
+          end
+
           # 文字列に変換する
           # @return [String]
           def to_s
@@ -283,8 +344,8 @@ module BCDice
           # @param [Number] times ダイスを振る回数のノード
           # @param [Number] sides ダイスの面数のノード
           def initialize(times, sides)
-            @times = times.literal
-            @sides = sides.literal
+            @times = times.eval(nil)
+            @sides = sides.eval(nil)
 
             # ダイスを振った結果の出力
             @text = nil
@@ -298,19 +359,19 @@ module BCDice
           # @param [Randomizer] randomizer ランダマイザ
           # @return [Integer] 評価結果（出目の合計値）
           def eval(randomizer)
-            dice_groups = randomizer.roll(@times, @sides)
-
-            # TODO: Ruby 2.4以降では Array#sum が使える
-            total = dice_groups.flatten.reduce(0, &:+)
+            dice_list = randomizer.roll(@times, @sides)
 
-            dice_str = dice_groups
-                       .map { |dice_list| "[#{dice_list.join(',')}]" }
-                       .join
-            @text = "#{total}#{dice_str}"
+            total = dice_list.sum()
+            @text = "#{total}[#{dice_list.join(',')}]"
 
             return total
           end
 
+          # @return [Boolean]
+          def include_dice?
+            true
+          end
+
           # 文字列に変換する
           # @return [String]
           def to_s
@@ -391,16 +452,21 @@ module BCDice
           # @param [Randomizer] randomizer ランダマイザ
           # @return [Integer] 評価結果（出目の合計値）
           def eval(randomizer)
-            sorted_values = randomizer.roll_once(@times, @sides).sort
+            sorted_values = randomizer.roll(@times, @sides).sort
             total = @filter
                     .apply[sorted_values, @n_filtering]
-                    .reduce(0, &:+)
+                    .sum()
 
             @text = "#{total}[#{sorted_values.join(',')}]"
 
             return total
           end
 
+          # @return [Boolean]
+          def include_dice?
+            true
+          end
+
           # 文字列に変換する
           # @return [String]
           def to_s
@@ -433,6 +499,11 @@ module BCDice
             @expr.eval(randomizer)
           end
 
+          # @return [Boolean]
+          def include_dice?
+            @expr.include_dice?
+          end
+
           # @return [String]
           def to_s
             "(#{@expr})"
@@ -473,6 +544,11 @@ module BCDice
             @literal
           end
 
+          # @return [Boolean]
+          def include_dice?
+            false
+          end
+
           # 文字列に変換する
           # @return [String]
           def to_s

data/lib/bcdice/common_command/add_dice/parser.rb

@@ -1,282 +1,382 @@
-# frozen_string_literal: true
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.5.1
+# from Racc grammar file "".
+#
 
-require "bcdice/arithmetic_evaluator"
-require "bcdice/normalize"
+require 'racc/parser.rb'
+
+
+require "bcdice/common_command/lexer"
 require "bcdice/common_command/add_dice/node"
 
 module BCDice
   module CommonCommand
-    class AddDice
-      # 加算ロールの構文解析器のクラス
-      class Parser
-        # 構文解析器を初期化する
-        # @param [String] expr 構文解析対象の文字列
-        def initialize(expr)
-          # 構文解析対象の文字列
-          @expr = expr
-          # 読み込んだトークンのインデックス
-          @idx = 0
-          # 構文解析エラーが発生したかどうか
-          @error = false
-          # 式にダイスロールが含まれるか
-          @contain_dice_roll = false
-
-          @is_secret = false
-        end
-
-        def secret?
-          @is_secret
-        end
-
-        # 構文解析を実行する
-        # @return [Node::Command, nil] 加算ロールコマンド
-        def parse()
-          lhs, cmp_op, rhs = @expr.partition(/[<>=]+/)
-
-          cmp_op = Normalize.comparison_operator(cmp_op)
-          if cmp_op && rhs.empty?
-            @error = true
-            return nil
-          end
-
-          if !rhs.empty? && rhs != "?"
-            ae = ArithmeticEvaluator.new(rhs)
-            rhs = ae.eval()
-
-            @error = ae.error?
-          end
-
-          @tokens = tokenize(lhs)
-          lhs = expr()
-
-          if @idx != @tokens.size || !@contain_dice_roll
-            @error = true
-          end
-
-          return AddDice::Node::Command.new(lhs, cmp_op, rhs)
-        end
-
-        # 構文解析エラーが発生したかどうかを返す
-        # @return [Boolean]
-        def error?
-          @error
-        end
-
-        private
-
-        # 構文解析対象の文字列をトークンの配列に変換する
-        # @return [Array<String>]
-        def tokenize(expr)
-          expr.gsub(%r{[\+\-\*/DURSKHL@()]}) { |e| " #{e} " }.split(" ")
-        end
-
-        # 式
-        def expr
-          @is_secret = consume("S")
-
-          return add()
-        end
-
-        # 加算、減算
-        def add
-          node = mul()
-
-          loop do
-            if consume("+")
-              op, rhs = sub_negative_number(:+, mul())
-              node = AddDice::Node::BinaryOp.new(node, op, rhs)
-            elsif consume("-")
-              op, rhs = sub_negative_number(:-, mul())
-              node = AddDice::Node::BinaryOp.new(node, op, rhs)
-            else
-              break
-            end
-          end
-
-          return node
-        end
-
-        # TODO: 処理の説明を書く
-        def sub_negative_number(op, rhs)
-          if rhs.is_a?(Node::Number) && rhs.literal < 0
-            if op == :+
-              return [:-, rhs.negate]
-            elsif op == :-
-              return [:+, rhs.negate]
-            end
-          end
-
-          [op, rhs]
-        end
-
-        # 乗算、除算
-        def mul
-          node = unary()
-
-          loop do
-            if consume("*")
-              node = AddDice::Node::BinaryOp.new(node, :*, unary())
-            elsif consume("/")
-              rhs = unary()
-              klass = divide_node_class()
-              node = klass.new(node, rhs)
-            else
-              break
-            end
-          end
-
-          return node
-        end
-
-        # 端数処理方法を示す記号を読み込み、対応する除算ノードのクラスを返す
-        # @return [Class] 除算ノードのクラス
-        def divide_node_class
-          if consume("U")
-            # 切り上げ
-            Node::DivideWithRoundingUp
-          elsif consume("R")
-            # 四捨五入
-            Node::DivideWithRoundingOff
-          else
-            # 切り捨て
-            Node::DivideWithRoundingDown
-          end
-        end
-
-        # 単項演算
-        def unary
-          if consume("+")
-            unary()
-          elsif consume("-")
-            node = unary()
-
-            case node
-            when Node::Negate
-              node.body
-            when Node::Number
-              node.negate()
-            else
-              AddDice::Node::Negate.new(node)
-            end
-          else
-            term()
-          end
-        end
-
-        # カッコ、ダイスロール
-        def term
-          if consume("(")
-            node = AddDice::Node::Parenthesis.new(add())
-            expect(")")
-
-            return node
-          else
-            dice_notation()
-          end
-        end
-
-        # ダイスロール、数値
-        def dice_notation
-          num = expect_number()
-          if consume("D")
-            times = num
-            sides = expect_number()
-
-            filter = dice_roll_filter()
-            if filter
-              # ダイスロール後のフィルタリングあり
-              n_filtering = expect_number()
-              @contain_dice_roll = true
-              return Node::DiceRollWithFilter.new(times, sides, n_filtering, filter)
-            end
-
-            # 通常のダイスロール
-            @contain_dice_roll = true
-            return Node::DiceRoll.new(times, sides)
-          end
-
-          return num
-        end
-
-        # ダイスロール：フィルタ処理
-        def dice_roll_filter
-          if consume("K", "H")
-            # 大きな出目から複数個取る
-            Node::DiceRollWithFilter::KEEP_HIGHEST
-          elsif consume("K", "L")
-            # 小さな出目から複数個取る
-            Node::DiceRollWithFilter::KEEP_LOWEST
-          elsif consume("D", "H")
-            # 大きな出目から複数個除く
-            Node::DiceRollWithFilter::DROP_HIGHEST
-          elsif consume("D", "L")
-            # 小さな出目から複数個除く
-            Node::DiceRollWithFilter::DROP_LOWEST
-          end
-        end
-
-        # トークンを消費する
-        #
-        # トークンと期待した文字列が合致していた場合、次のトークンに進む。
-        # 合致していなかった場合は、進まない。
-        #
-        # @param [String] expected 期待する文字列
-        # @return [true] トークンと期待した文字列が合致していた場合
-        # @return [false] トークンと期待した文字列が合致していなかった場合
-        def consume(*expected)
-          target = @tokens.slice(@idx, expected.length)
-          unless target == expected
-            return false
-          end
-
-          @idx += expected.length
-          return true
-        end
-
-        # 指定された文字列のトークンを要求する
-        #
-        # トークンと期待した文字列が合致していなかった場合、エラーとする。
-        # エラーの有無にかかわらず、次のトークンに進む。
-        #
-        # @param [String] str 期待する文字列
-        # @return [void]
-        def expect(str)
-          if @tokens[@idx] != str
-            @error = true
-          end
-
-          @idx += 1
-        end
-
-        # 整数のトークンを要求する
-        #
-        # 整数のトークンならば、対応する整数のノードを返す。
-        # そうでなければエラーとし、整数0のノードを返す。
-        #
-        # エラーの有無にかかわらず、次のトークンに進む。
-        #
-        # @return [Node::Number] 整数のノード
-        def expect_number()
-          unless integer?(@tokens[@idx])
-            @error = true
-            @idx += 1
-            return AddDice::Node::Number.new(0)
-          end
-
-          ret = @tokens[@idx].to_i
-          @idx += 1
-          return AddDice::Node::Number.new(ret)
-        end
-
-        # 文字列が整数かどうかを返す
-        # @param [String] str 対象文字列
-        # @return [Boolean]
-        def integer?(str)
-          # Ruby 1.9 以降では Kernel.#Integer を使うべき
-          # Ruby 1.8 にもあるが、基数を指定できない問題がある
-          !/^\d+$/.match(str).nil?
-        end
-      end
+    module AddDice
+      class Parser < Racc::Parser
+
+
+def self.parse(source)
+  new.parse(source)
+end
+
+def parse(source)
+  @lexer = Lexer.new(source)
+  do_parse()
+rescue ParseError
+  nil
+end
+
+private
+
+def next_token
+  @lexer.next_token
+end
+
+# 加減算の右辺が負数である場合に加減算を逆転させる
+def expand_negate(op, rhs)
+  if rhs.is_a?(Node::Negate)
+    if op == :+
+      return [:-, rhs.body]
+    elsif op == :-
+      return [:+, rhs.body]
     end
   end
+
+  [op, rhs]
+end
+##### State transition tables begin ###
+
+racc_action_table = [
+    13,    16,    17,    18,    19,    13,    32,    13,     3,     8,
+     9,     4,    13,    12,    13,    26,     8,     9,    12,    13,
+    12,     8,     9,     8,     9,    12,    13,    12,     8,     9,
+    14,    13,    12,    13,    22,     8,     9,    13,    13,    12,
+     8,     9,     8,     9,    12,    15,    12,     8,     9,   nil,
+    12,    12,   nil,    16,    17,    16,    17,    18,    19,    18,
+    19,    34,    35,    38,    37,    40,    41,    42,    43 ]
+
+racc_action_check = [
+    15,    23,    23,     6,     6,    22,    23,     2,     0,    15,
+    15,     1,     8,    15,     9,    15,     2,     2,    22,    12,
+     2,     8,     8,     9,     9,     8,    16,     9,    12,    12,
+     4,    17,    12,    18,    11,    16,    16,    36,    19,    16,
+    17,    17,    18,    18,    17,     5,    18,    19,    19,   nil,
+    36,    19,   nil,     5,     5,    25,    25,    27,    27,    28,
+    28,    30,    30,    31,    31,    37,    37,    38,    38 ]
+
+racc_action_pointer = [
+     4,    11,     5,   nil,    30,    42,   -10,   nil,    10,    12,
+   nil,    29,    17,   nil,   nil,    -2,    24,    29,    31,    36,
+   nil,   nil,     3,   -10,   nil,    44,   nil,    44,    46,   nil,
+    52,    58,   nil,   nil,   nil,   nil,    35,    58,    60,   nil,
+   nil,   nil,   nil,   nil ]
+
+racc_action_default = [
+    -3,   -29,   -29,    -4,   -29,    -1,    -9,   -12,   -29,   -29,
+   -18,   -22,   -29,   -28,    44,   -29,   -29,   -29,   -29,   -29,
+   -16,   -17,   -20,   -29,    -2,    -5,    -6,    -7,    -8,   -10,
+   -13,   -19,   -27,   -11,   -14,   -15,   -29,   -29,   -29,   -21,
+   -23,   -24,   -25,   -26 ]
+
+racc_goto_table = [
+    31,     1,     5,    27,    28,     2,    20,    21,    24,    33,
+    36,   nil,    23,   nil,    39,    25,    29,    30 ]
+
+racc_goto_check = [
+     9,     1,     3,     5,     5,     2,     6,     6,     4,     7,
+    10,   nil,     3,   nil,     9,     3,     6,     6 ]
+
+racc_goto_pointer = [
+   nil,     1,     5,     0,    -7,   -13,    -2,   -21,   nil,   -22,
+   -21 ]
+
+racc_goto_default = [
+   nil,   nil,   nil,   nil,   nil,     6,     7,   nil,    10,    11,
+   nil ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  2, 19, :_reduce_1,
+  4, 19, :_reduce_2,
+  0, 20, :_reduce_3,
+  1, 20, :_reduce_4,
+  1, 22, :_reduce_none,
+  1, 22, :_reduce_6,
+  3, 21, :_reduce_7,
+  3, 21, :_reduce_8,
+  1, 21, :_reduce_none,
+  3, 23, :_reduce_10,
+  4, 23, :_reduce_11,
+  1, 23, :_reduce_none,
+  0, 25, :_reduce_13,
+  1, 25, :_reduce_14,
+  1, 25, :_reduce_15,
+  2, 24, :_reduce_16,
+  2, 24, :_reduce_17,
+  1, 24, :_reduce_none,
+  3, 26, :_reduce_19,
+  2, 26, :_reduce_20,
+  5, 26, :_reduce_21,
+  1, 26, :_reduce_none,
+  2, 28, :_reduce_23,
+  2, 28, :_reduce_24,
+  2, 28, :_reduce_25,
+  2, 28, :_reduce_26,
+  3, 27, :_reduce_27,
+  1, 27, :_reduce_28 ]
+
+racc_reduce_n = 29
+
+racc_shift_n = 44
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :NUMBER => 2,
+  :CMP_OP => 3,
+  :S => 4,
+  :D => 5,
+  :K => 6,
+  :H => 7,
+  :L => 8,
+  :U => 9,
+  :R => 10,
+  :PLUS => 11,
+  :MINUS => 12,
+  :ASTERISK => 13,
+  :SLASH => 14,
+  :PARENL => 15,
+  :PARENR => 16,
+  :QUESTION => 17 }
+
+racc_nt_base = 18
+
+racc_use_result_var = true
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "NUMBER",
+  "CMP_OP",
+  "S",
+  "D",
+  "K",
+  "H",
+  "L",
+  "U",
+  "R",
+  "PLUS",
+  "MINUS",
+  "ASTERISK",
+  "SLASH",
+  "PARENL",
+  "PARENR",
+  "QUESTION",
+  "$start",
+  "command",
+  "secret",
+  "add",
+  "target",
+  "mul",
+  "unary",
+  "round_type",
+  "dice",
+  "term",
+  "filter_type" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+def _reduce_1(val, _values, result)
+           secret, lhs = val
+           raise ParseError unless lhs.include_dice?
+
+           result = Node::Command.new(secret, lhs)
+
+    result
+end
+
+def _reduce_2(val, _values, result)
+           secret, lhs, cmp_op, rhs = val
+           raise ParseError if !lhs.include_dice? || rhs.include_dice? || cmp_op.nil?
+
+           result = Node::Command.new(secret, lhs, cmp_op, rhs)
+
+    result
+end
+
+def _reduce_3(val, _values, result)
+ result = false
+    result
+end
+
+def _reduce_4(val, _values, result)
+ result = true
+    result
+end
+
+# reduce 5 omitted
+
+def _reduce_6(val, _values, result)
+ result = Node::UndecidedTarget.instance
+    result
+end
+
+def _reduce_7(val, _values, result)
+      lhs = val[0]
+      op, rhs = expand_negate(:+, val[2])
+      result = Node::BinaryOp.new(lhs, op, rhs)
+
+    result
+end
+
+def _reduce_8(val, _values, result)
+      lhs = val[0]
+      op, rhs = expand_negate(:-, val[2])
+      result = Node::BinaryOp.new(lhs, op, rhs)
+
+    result
+end
+
+# reduce 9 omitted
+
+def _reduce_10(val, _values, result)
+      lhs = val[0]
+      rhs = val[2]
+      result = Node::BinaryOp.new(lhs, :*, rhs)
+
+    result
+end
+
+def _reduce_11(val, _values, result)
+       lhs = val[0]
+       rhs = val[2]
+       divied_class = val[3]
+       result = divied_class.new(lhs, rhs)
+
+    result
+end
+
+# reduce 12 omitted
+
+def _reduce_13(val, _values, result)
+ result = Node::DivideWithRoundingDown
+    result
+end
+
+def _reduce_14(val, _values, result)
+ result = Node::DivideWithRoundingUp
+    result
+end
+
+def _reduce_15(val, _values, result)
+ result = Node::DivideWithRoundingOff
+    result
+end
+
+def _reduce_16(val, _values, result)
+ result = val[1]
+    result
+end
+
+def _reduce_17(val, _values, result)
+         body = val[1]
+         result = body.is_a?(Node::Negate) ? body.body : Node::Negate.new(body)
+
+    result
 end
+
+# reduce 18 omitted
+
+def _reduce_19(val, _values, result)
+        times = val[0]
+        sides = val[2]
+        raise ParseError if times.include_dice? || sides.include_dice?
+
+        result = Node::DiceRoll.new(times, sides)
+
+    result
+end
+
+def _reduce_20(val, _values, result)
+        times = val[0]
+        sides = Node::Number.new(6)
+        raise ParseError if times.include_dice?
+
+        result = Node::DiceRoll.new(times, sides)
+
+    result
+end
+
+def _reduce_21(val, _values, result)
+        times = val[0]
+        sides = val[2]
+        filter = val[3]
+        n_filtering = val[4]
+        raise ParseError if times.include_dice? || sides.include_dice? || n_filtering.include_dice?
+
+        result = Node::DiceRollWithFilter.new(times, sides, n_filtering, filter)
+
+    result
+end
+
+# reduce 22 omitted
+
+def _reduce_23(val, _values, result)
+ result = Node::DiceRollWithFilter::KEEP_HIGHEST
+    result
+end
+
+def _reduce_24(val, _values, result)
+ result = Node::DiceRollWithFilter::KEEP_LOWEST
+    result
+end
+
+def _reduce_25(val, _values, result)
+ result = Node::DiceRollWithFilter::DROP_HIGHEST
+    result
+end
+
+def _reduce_26(val, _values, result)
+ result = Node::DiceRollWithFilter::DROP_LOWEST
+    result
+end
+
+def _reduce_27(val, _values, result)
+ result = Node::Parenthesis.new(val[1])
+    result
+end
+
+def _reduce_28(val, _values, result)
+ result = Node::Number.new(val[0])
+    result
+end
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
+
+      end   # class Parser
+    end   # module AddDice
+  end   # module CommonCommand
+end   # module BCDice