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

data/lib/bcdice/common_command/barabara_dice/parser.y

@@ -0,0 +1,107 @@
+class BCDice::CommonCommand::BarabaraDice::Parser
+  token NUMBER B R U C F S PLUS MINUS ASTERISK SLASH PARENL PARENR BRACKETL BRACKETR LESS GREATER EQUAL NOT AT CMP_OP
+
+  rule
+    expr: secret notations target
+        {
+          result = Node::Command.new(
+            secret: val[0],
+            notations: val[1],
+            cmp_op: val[2][:cmp_op],
+            target_number: val[2][:target]
+          )
+        }
+
+    secret: /* none */
+          { result = false }
+          | S
+          { result = true }
+
+    target: /* none */
+          { result = {} }
+          | CMP_OP add
+          {
+            cmp_op, target = val
+            raise ParseError unless cmp_op
+
+            result = {cmp_op: cmp_op, target: target}
+          }
+
+    notations: notations PLUS dice
+             {
+               notations = val[0]
+               notations.push(val[2])
+               result = notations
+             }
+             | dice
+             { result = [val[0]] }
+
+    dice: term B term
+        {
+          times = val[0]
+          sides = val[2]
+          result = Node::Notation.new(times, sides)
+        }
+
+    add: add PLUS mul
+       { result = Arithmetic::Node::BinaryOp.new(val[0], :+, val[2]) }
+       | add MINUS mul
+       { result = Arithmetic::Node::BinaryOp.new(val[0], :-, val[2]) }
+       | mul
+
+    mul: mul ASTERISK unary
+       { result = Arithmetic::Node::BinaryOp.new(val[0], :*, val[2]) }
+       | mul SLASH unary round_type
+       {
+         divied_class = val[3]
+         result = divied_class.new(val[0], val[2])
+       }
+       | unary
+
+    round_type: /* none */
+              { result = Arithmetic::Node::DivideWithGameSystemDefault }
+              | U
+              { result = Arithmetic::Node::DivideWithCeil }
+              | C
+              { result = Arithmetic::Node::DivideWithCeil }
+              | R
+              { result = Arithmetic::Node::DivideWithRound }
+              | F
+              { result = Arithmetic::Node::DivideWithFloor }
+
+    unary: PLUS unary
+         { result = val[1] }
+         | MINUS unary
+         { result = Arithmetic::Node::Negative.new(val[1]) }
+         | term
+
+    term: PARENL add PARENR
+        { result = val[1] }
+        | NUMBER
+        { result = Arithmetic::Node::Number.new(val[0]) }
+end
+
+---- header
+
+require "bcdice/common_command/lexer"
+require "bcdice/common_command/reroll_dice/node"
+require "bcdice/arithmetic/node"
+
+---- inner
+
+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

data/lib/bcdice/common_command/calc.rb

@@ -1,38 +1,15 @@
+require "bcdice/common_command/calc/parser"
+
 module BCDice
   module CommonCommand
-    class Calc
+    module Calc
       PREFIX_PATTERN = /C/.freeze
 
-      # @param command [String]
-      # @param _randomizer [Randomizer]
-      # @param game_system [Base]
-      def initialize(command, _randomizer, game_system)
-        @command = command
-        @game_system = game_system
-
-        @is_secret = false
-      end
-
-      # @return [Boolean]
-      def secret?
-        @is_secret
-      end
-
-      # @return [String, nil]
-      def eval
-        m = %r{^(S)?C([\+\-\*/\d\(\)]+)$}i.match(@command)
-        unless m
-          return nil
-        end
-
-        @is_secret = !m[1].nil?
-        expr = ArithmeticEvaluator.new(m[2], round_type: @game_system.round_type)
-        value = expr.eval()
-        if expr.error?
-          return nil
+      class << self
+        def eval(command, game_system, _randomizer)
+          cmd = Parser.parse(command)
+          cmd&.eval(game_system.round_type)
         end
-
-        return "計算結果 ＞ #{value}"
       end
     end
   end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module BCDice
+  module CommonCommand
+    module Calc
+      module Node
+        class Command
+          def initialize(secret:, expr:)
+            @secret = secret
+            @expr = expr
+          end
+
+          def eval(round_type)
+            value =
+              begin
+                @expr.eval(round_type)
+              rescue ZeroDivisionError
+                "ゼロ除算が発生したため計算できませんでした"
+              end
+
+            Result.new.tap do |r|
+              r.secret = @secret
+              r.text = "計算結果 ＞ #{value}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,271 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.5.1
+# from Racc grammar file "".
+#
+
+require 'racc/parser.rb'
+
+
+require "bcdice/common_command/lexer"
+require "bcdice/common_command/calc/node"
+require "bcdice/arithmetic/node"
+
+module BCDice
+  module CommonCommand
+    module Calc
+      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
+##### State transition tables begin ###
+
+racc_action_table = [
+    14,     3,    14,    15,    16,     4,    10,    11,    10,    11,
+    13,    14,    13,    14,    17,    18,     5,    10,    11,    10,
+    11,    13,    14,    13,    14,    17,    18,     6,    10,    11,
+    10,    11,    13,    14,    13,    14,    17,    18,   nil,    10,
+    11,    10,    11,    13,   nil,    13,    15,    16,   nil,   nil,
+   nil,    26,    30,    28,    29,    31 ]
+
+racc_action_check = [
+     5,     0,    10,     7,     7,     1,     5,     5,    10,    10,
+     5,    11,    10,    13,     8,     8,     2,    11,    11,    13,
+    13,    11,    15,    13,    16,    22,    22,     4,    15,    15,
+    16,    16,    15,    17,    16,    18,    23,    23,   nil,    17,
+    17,    18,    18,    17,   nil,    18,    21,    21,   nil,   nil,
+   nil,    21,    25,    25,    25,    25 ]
+
+racc_action_pointer = [
+    -6,     5,    11,   nil,    27,    -2,   nil,    -5,     4,   nil,
+     0,     9,   nil,    11,   nil,    20,    22,    31,    33,   nil,
+   nil,    38,    15,    26,   nil,    49,   nil,   nil,   nil,   nil,
+   nil,   nil ]
+
+racc_action_default = [
+    -2,   -20,   -20,    -3,   -20,   -20,    32,    -1,    -6,    -9,
+   -20,   -20,   -17,   -20,   -19,   -20,   -20,   -20,   -20,   -15,
+   -16,   -20,    -4,    -5,    -7,   -10,   -18,    -8,   -11,   -12,
+   -13,   -14 ]
+
+racc_goto_table = [
+     7,     1,    19,    20,    22,    23,     2,    27,    21,    24,
+    25 ]
+
+racc_goto_check = [
+     3,     1,     5,     5,     4,     4,     2,     6,     3,     5,
+     5 ]
+
+racc_goto_pointer = [
+   nil,     1,     6,    -5,   -11,    -8,   -18,   nil ]
+
+racc_goto_default = [
+   nil,   nil,   nil,   nil,     8,     9,   nil,    12 ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  3, 15, :_reduce_1,
+  0, 16, :_reduce_2,
+  1, 16, :_reduce_3,
+  3, 17, :_reduce_4,
+  3, 17, :_reduce_5,
+  1, 17, :_reduce_none,
+  3, 18, :_reduce_7,
+  4, 18, :_reduce_8,
+  1, 18, :_reduce_none,
+  0, 20, :_reduce_10,
+  1, 20, :_reduce_11,
+  1, 20, :_reduce_12,
+  1, 20, :_reduce_13,
+  1, 20, :_reduce_14,
+  2, 19, :_reduce_15,
+  2, 19, :_reduce_16,
+  1, 19, :_reduce_none,
+  3, 21, :_reduce_18,
+  1, 21, :_reduce_19 ]
+
+racc_reduce_n = 20
+
+racc_shift_n = 32
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :NUMBER => 2,
+  :R => 3,
+  :U => 4,
+  :C => 5,
+  :F => 6,
+  :S => 7,
+  :PLUS => 8,
+  :MINUS => 9,
+  :ASTERISK => 10,
+  :SLASH => 11,
+  :PARENL => 12,
+  :PARENR => 13 }
+
+racc_nt_base = 14
+
+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",
+  "R",
+  "U",
+  "C",
+  "F",
+  "S",
+  "PLUS",
+  "MINUS",
+  "ASTERISK",
+  "SLASH",
+  "PARENL",
+  "PARENR",
+  "$start",
+  "expr",
+  "secret",
+  "add",
+  "mul",
+  "unary",
+  "round_type",
+  "term" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+def _reduce_1(val, _values, result)
+          result = Node::Command.new(
+            secret: val[0],
+            expr: val[2]
+          )
+
+    result
+end
+
+def _reduce_2(val, _values, result)
+ result = false
+    result
+end
+
+def _reduce_3(val, _values, result)
+ result = true
+    result
+end
+
+def _reduce_4(val, _values, result)
+ result = Arithmetic::Node::BinaryOp.new(val[0], :+, val[2])
+    result
+end
+
+def _reduce_5(val, _values, result)
+ result = Arithmetic::Node::BinaryOp.new(val[0], :-, val[2])
+    result
+end
+
+# reduce 6 omitted
+
+def _reduce_7(val, _values, result)
+ result = Arithmetic::Node::BinaryOp.new(val[0], :*, val[2])
+    result
+end
+
+def _reduce_8(val, _values, result)
+         divied_class = val[3]
+         result = divied_class.new(val[0], val[2])
+
+    result
+end
+
+# reduce 9 omitted
+
+def _reduce_10(val, _values, result)
+ result = Arithmetic::Node::DivideWithGameSystemDefault
+    result
+end
+
+def _reduce_11(val, _values, result)
+ result = Arithmetic::Node::DivideWithCeil
+    result
+end
+
+def _reduce_12(val, _values, result)
+ result = Arithmetic::Node::DivideWithCeil
+    result
+end
+
+def _reduce_13(val, _values, result)
+ result = Arithmetic::Node::DivideWithRound
+    result
+end
+
+def _reduce_14(val, _values, result)
+ result = Arithmetic::Node::DivideWithFloor
+    result
+end
+
+def _reduce_15(val, _values, result)
+ result = val[1]
+    result
+end
+
+def _reduce_16(val, _values, result)
+ result = Arithmetic::Node::Negative.new(val[1])
+    result
+end
+
+# reduce 17 omitted
+
+def _reduce_18(val, _values, result)
+ result = val[1]
+    result
+end
+
+def _reduce_19(val, _values, result)
+ result = Arithmetic::Node::Number.new(val[0])
+    result
+end
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
+
+      end   # class Parser
+    end   # module Calc
+  end   # module CommonCommand
+end   # module BCDice