bcdice 3.0.0.pre.alpha.1 → 3.1.0

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

@@ -1,282 +1,399 @@
-# 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,     3,    32,    13,     4,    13,
+    14,     8,     9,    22,    13,    12,    13,    26,     8,     9,
+     8,     9,    12,    13,    12,     8,     9,     8,     9,    12,
+    13,    12,    13,   nil,     8,     9,    13,    13,    12,    13,
+   nil,     8,     9,     8,     9,    12,    15,    12,     8,     9,
+   nil,    12,    12,   nil,    12,   nil,    16,    17,    35,    37,
+    34,    36,    16,    17,    18,    19,    18,    19,    40,    39,
+    42,    43,    44,    45 ]
+
+racc_action_check = [
+    15,    23,    23,     6,     6,     0,    23,     2,     1,     8,
+     4,    15,    15,    11,     9,    15,    12,    15,     2,     2,
+     8,     8,     2,    16,     8,     9,     9,    12,    12,     9,
+    17,    12,    18,   nil,    16,    16,    22,    19,    16,    38,
+   nil,    17,    17,    18,    18,    17,     5,    18,    19,    19,
+   nil,    22,    19,   nil,    38,   nil,     5,     5,    30,    30,
+    30,    30,    25,    25,    27,    27,    28,    28,    31,    31,
+    39,    39,    40,    40 ]
+
+racc_action_pointer = [
+     1,     8,     5,   nil,    10,    43,   -12,   nil,     7,    12,
+   nil,     8,    14,   nil,   nil,    -2,    21,    28,    30,    35,
+   nil,   nil,    34,   -12,   nil,    49,   nil,    49,    51,   nil,
+    49,    63,   nil,   nil,   nil,   nil,   nil,   nil,    37,    63,
+    65,   nil,   nil,   nil,   nil,   nil ]
+
+racc_action_default = [
+    -3,   -31,   -31,    -4,   -31,    -1,    -9,   -12,   -31,   -31,
+   -20,   -24,   -31,   -30,    46,   -31,   -31,   -31,   -31,   -31,
+   -18,   -19,   -22,   -31,    -2,    -5,    -6,    -7,    -8,   -10,
+   -13,   -21,   -29,   -11,   -14,   -15,   -16,   -17,   -31,   -31,
+   -31,   -23,   -25,   -26,   -27,   -28 ]
+
+racc_goto_table = [
+    31,     5,    20,    21,    27,    28,     1,     2,    24,    33,
+    38,    23,    29,    30,    25,   nil,    41 ]
+
+racc_goto_check = [
+     9,     3,     6,     6,     5,     5,     1,     2,     4,     7,
+    10,     3,     6,     6,     3,   nil,     9 ]
+
+racc_goto_pointer = [
+   nil,     6,     7,    -1,    -7,   -12,    -6,   -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, 21, :_reduce_1,
+  4, 21, :_reduce_2,
+  0, 22, :_reduce_3,
+  1, 22, :_reduce_4,
+  1, 24, :_reduce_none,
+  1, 24, :_reduce_6,
+  3, 23, :_reduce_7,
+  3, 23, :_reduce_8,
+  1, 23, :_reduce_none,
+  3, 25, :_reduce_10,
+  4, 25, :_reduce_11,
+  1, 25, :_reduce_none,
+  0, 27, :_reduce_13,
+  1, 27, :_reduce_14,
+  1, 27, :_reduce_15,
+  1, 27, :_reduce_16,
+  1, 27, :_reduce_17,
+  2, 26, :_reduce_18,
+  2, 26, :_reduce_19,
+  1, 26, :_reduce_none,
+  3, 28, :_reduce_21,
+  2, 28, :_reduce_22,
+  5, 28, :_reduce_23,
+  1, 28, :_reduce_none,
+  2, 30, :_reduce_25,
+  2, 30, :_reduce_26,
+  2, 30, :_reduce_27,
+  2, 30, :_reduce_28,
+  3, 29, :_reduce_29,
+  1, 29, :_reduce_30 ]
+
+racc_reduce_n = 31
+
+racc_shift_n = 46
+
+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,
+  :F => 11,
+  :C => 12,
+  :PLUS => 13,
+  :MINUS => 14,
+  :ASTERISK => 15,
+  :SLASH => 16,
+  :PARENL => 17,
+  :PARENR => 18,
+  :QUESTION => 19 }
+
+racc_nt_base = 20
+
+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",
+  "F",
+  "C",
+  "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::DivideWithGameSystemDefault
+    result
+end
+
+def _reduce_14(val, _values, result)
+ result = Node::DivideWithRoundingDown
+    result
+end
+
+def _reduce_15(val, _values, result)
+ result = Node::DivideWithRoundingUp
+    result
+end
+
+def _reduce_16(val, _values, result)
+ result = Node::DivideWithRoundingUp
+    result
+end
+
+def _reduce_17(val, _values, result)
+ result = Node::DivideWithRoundingOff
+    result
+end
+
+def _reduce_18(val, _values, result)
+ result = val[1]
+    result
+end
+
+def _reduce_19(val, _values, result)
+         body = val[1]
+         result = body.is_a?(Node::Negate) ? body.body : Node::Negate.new(body)
+
+    result
+end
+
+# reduce 20 omitted
+
+def _reduce_21(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_22(val, _values, result)
+        times = val[0]
+        raise ParseError if times.include_dice?
+
+        result = Node::ImplicitSidesDiceRoll.new(times)
+
+    result
 end
+
+def _reduce_23(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 24 omitted
+
+def _reduce_25(val, _values, result)
+ result = Node::DiceRollWithFilter::KEEP_HIGHEST
+    result
+end
+
+def _reduce_26(val, _values, result)
+ result = Node::DiceRollWithFilter::KEEP_LOWEST
+    result
+end
+
+def _reduce_27(val, _values, result)
+ result = Node::DiceRollWithFilter::DROP_HIGHEST
+    result
+end
+
+def _reduce_28(val, _values, result)
+ result = Node::DiceRollWithFilter::DROP_LOWEST
+    result
+end
+
+def _reduce_29(val, _values, result)
+ result = Node::Parenthesis.new(val[1])
+    result
+end
+
+def _reduce_30(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