rubic 0.2.0 → 0.3.0

data/lib/rubic/parser.y

@@ -21,7 +21,7 @@ rule
             []
           }
         | IDENT
-        | NUMBER
+        | number
         | STRING
         | define
         | cond
@@ -29,6 +29,8 @@ rule
         | lambda
         | let
         | quote
+        | set
+        | begin
 
   seq     : expr
             {
@@ -123,59 +125,147 @@ rule
           {
             [:quote, val[1]]
           }
+
+  /* set expression */
+  set : '(' KW_SET_BANG IDENT expr ')'
+        {
+          [:set!, val[2], val[3]]
+        }
+
+  /* begin expression */
+  begin : '(' KW_BEGIN seq ')'
+          {
+            [:begin, *val[2]]
+          }
+
+  number  : binary NUM_END      { val[0] }
+          | octal NUM_END       { val[0] }
+          | decimal NUM_END     { val[0] }
+          | hexadecimal NUM_END { val[0] }
+
+  binary    : b_prefix b_complex
+              { val[0].nil? ? val[1] : (val[0] ? inexact_to_exact(val[1]) : exact_to_inexact(val[1])) }
+  b_complex : b_real
+            | b_real '@' b_real      { normalize_number Complex.polar(val[0], val[2]) }
+            | b_real '+' b_ureal 'i' { normalize_number Complex(val[0], val[2]) }
+            | b_real '-' b_ureal 'i' { normalize_number Complex(val[0], -val[2]) }
+            | b_real '+' 'i'         { Complex(val[0], 1) }
+            | b_real '-' 'i'         { Complex(val[0], -1) }
+            | '+' b_ureal 'i'        { normalize_number Complex(0, val[1]) }
+            | '-' b_ureal 'i'        { normalize_number Complex(0, -val[1]) }
+            | '+' 'i'                { Complex(0, 1) }
+            | '-' 'i'                { Complex(0, -1) }
+  b_real    : sign b_ureal           { val[0] == '-' ? -val[1] : val[1] }
+  b_ureal   : b_uint
+            | b_uint '/' b_uint      { normalize_number Rational(val[0], val[2]) }
+  b_uint    : b_chars                { val[0].to_i(2) }
+  b_chars   : b_char
+            | b_chars b_char         { val[0] << val[1] }
+  b_char    : '0' | '1'
+  b_prefix  : NUM_PREFIX_B exactness { val[1] }
+            | exactness NUM_PREFIX_B { val[0] }
+
+  octal     : o_prefix o_complex
+              { val[0].nil? ? val[1] : (val[0] ? inexact_to_exact(val[1]) : exact_to_inexact(val[1])) }
+  o_complex : o_real
+            | o_real '@' o_real      { normalize_number Complex.polar(val[0], val[2]) }
+            | o_real '+' o_ureal 'i' { normalize_number Complex(val[0], val[2]) }
+            | o_real '-' o_ureal 'i' { normalize_number Complex(val[0], -val[2]) }
+            | o_real '+' 'i'         { Complex(val[0], 1) }
+            | o_real '-' 'i'         { Complex(val[0], -1) }
+            | '+' o_ureal 'i'        { normalize_number Complex(0, val[1]) }
+            | '-' o_ureal 'i'        { normalize_number Complex(0, -val[1]) }
+            | '+' 'i'                { Complex(0, 1) }
+            | '-' 'i'                { Complex(0, -1) }
+  o_real    : sign o_ureal           { val[0] == '-' ? -val[1] : val[1] }
+  o_ureal   : o_uint
+            | o_uint '/' o_uint      { normalize_number Rational(val[0], val[2]) }
+  o_uint    : o_chars                { val[0].to_i(8) }
+  o_chars   : o_char
+            | o_chars o_char         { val[0] << val[1] }
+  o_char    : '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7'
+  o_prefix  : NUM_PREFIX_O exactness { val[1] }
+            | exactness NUM_PREFIX_O { val[0] }
+
+  decimal   : d_prefix d_complex
+              { val[0].nil? ? val[1] : (val[0] ? inexact_to_exact(val[1]) : exact_to_inexact(val[1])) }
+  d_complex : d_real
+            | d_real '@' d_real      { normalize_number Complex.polar(val[0], val[2]) }
+            | d_real '+' d_ureal 'i' { normalize_number Complex(val[0], val[2]) }
+            | d_real '-' d_ureal 'i' { normalize_number Complex(val[0], -val[2]) }
+            | d_real '+' 'i'         { Complex(val[0], 1) }
+            | d_real '-' 'i'         { Complex(val[0], -1) }
+            | '+' d_ureal 'i'        { normalize_number Complex(0, val[1]) }
+            | '-' d_ureal 'i'        { normalize_number Complex(0, -val[1]) }
+            | '+' 'i'                { Complex(0, 1) }
+            | '-' 'i'                { Complex(0, -1) }
+  d_real    : sign d_ureal           { val[0] == '-' ? -val[1] : val[1] }
+  d_ureal   : d_uint
+            | d_uint '/' d_uint      { normalize_number Rational(val[0], val[2]) }
+            | d_decimal
+  d_decimal : d_uint suffix          { val[0].to_f * (10 ** val[1]) }
+            | '.' d_chars suffix     { "0.#{val[1]}".to_f * (10 ** val[2]) }
+            | d_chars '.' d_chars suffix
+              { "#{val[0]}.#{val[2]}".to_f * (10 ** val[3]) }
+            | d_chars '.' suffix     { val[0].to_f * (10 ** val[2]) }
+  d_uint    : d_chars                { val[0].to_i(10) }
+  d_chars   : d_char
+            | d_chars d_char         { val[0] << val[1] }
+  d_char    : '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
+  d_prefix  : NUM_PREFIX_D exactness { val[1] }
+            | exactness NUM_PREFIX_D { val[0] }
+            | exactness
+
+  hexadecimal : h_prefix h_complex
+                { val[0].nil? ? val[1] : (val[0] ? to_exact(val[1]) : exact_to_inexact(val[1])) }
+  h_complex : h_real
+            | h_real '@' h_real      { normalize_number Complex.polar(val[0], val[2]) }
+            | h_real '+' h_ureal 'i' { normalize_number Complex(val[0], val[2]) }
+            | h_real '-' h_ureal 'i' { normalize_number Complex(val[0], -val[2]) }
+            | h_real '+' 'i'         { Complex(val[0], 1) }
+            | h_real '-' 'i'         { Complex(val[0], -1) }
+            | '+' h_ureal 'i'        { normalize_number Complex(0, val[1]) }
+            | '-' h_ureal 'i'        { normalize_number Complex(0, -val[1]) }
+            | '+' 'i'                { Complex(0, 1) }
+            | '-' 'i'                { Complex(0, -1) }
+  h_real    : sign h_ureal           { val[0] == '-' ? -val[1] : val[1] }
+  h_ureal   : h_uint
+            | h_uint '/' h_uint      { normalize_number Rational(val[0], val[2]) }
+  h_uint    : h_chars                { val[0].to_i(16) }
+  h_chars   : h_char
+            | h_chars h_char         { val[0] << val[1] }
+  h_char    : '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
+            | 'a' | 'b' | 'c' | 'd' | 'e' | 'f'
+  h_prefix  : NUM_PREFIX_X exactness { val[1] }
+            | exactness NUM_PREFIX_X { val[0] }
+
+  suffix    : /* empty */
+              { 0 }
+            | exponent_marker sign d_chars
+              { val[1] == '-' ? -val[2].to_i : val[2].to_i }
+  exponent_marker : 'e'
+  sign      : /* empty */ | U_PLUS | U_MINUS
+  exactness : /* empty */ | NUM_PREFIX_E | NUM_PREFIX_I
 end
 
 ---- header
-require 'strscan'
+require 'rubic/lexer'
+require 'rubic/util'
 
 module Rubic
 
 ---- inner
-EOT = [false, nil] # end of token
-SYM_CHARS = Regexp.escape("+-*/<>=?")
+include Rubic::Util
 
 def parse(str)
-  @s = StringScanner.new(str)
+  @lexer = Rubic::Lexer.new(str)
   do_parse
 end
 
+private
+
 def next_token
-  @s.skip(/\s+/)
-  return EOT if @s.eos?
-
-  case
-  when @s.scan(/[0-9]+(\.[0-9]+)?/)
-    [:NUMBER, @s[0].include?('.') ? @s[0].to_f : @s[0].to_i]
-  when @s.scan(/[()']/)
-    [@s[0], nil]
-  when @s.scan(/[A-Za-z_#{SYM_CHARS}][A-Za-z0-9_#{SYM_CHARS}]*/o)
-    case @s[0] # keyword check
-    when 'define'
-      [:KW_DEFINE, nil]
-    when 'cond'
-      [:KW_COND, nil]
-    when 'else'
-      [:KW_ELSE, nil]
-    when 'if'
-      [:KW_IF, nil]
-    when 'and'
-      [:KW_AND, nil]
-    when 'or'
-      [:KW_OR, nil]
-    when 'lambda'
-      [:KW_LAMBDA, nil]
-    when 'let'
-      [:KW_LET, nil]
-    when 'quote'
-      [:KW_QUOTE, nil]
-    else
-      [:IDENT, @s[0].to_sym]
-    end
-  when @s.scan(/"([^"]*)"/)
-    [:STRING, @s[1]]
-  else
-    raise Rubic::ParseError, "unknown character #{@s.getch}"
-  end
+  @lexer.next_token
 end
 
 def on_error(t, val, vstack)

data/lib/rubic/util.rb

@@ -0,0 +1,42 @@
+module Rubic
+  module Util
+    def inexact_to_exact(num)
+      case num
+      when Complex
+        r = inexact_to_exact(num.real)
+        i = inexact_to_exact(num.imag)
+        normalize_number Complex(r, i)
+      when Float
+        normalize_number num.rationalize
+      when Rational, Integer
+        num
+      else
+        raise TypeError, "unexpected type of number: #{num.class}"
+      end
+    end
+
+    def exact_to_inexact(num)
+      case num
+      when Complex
+        r = exact_to_inexact(num.real)
+        i = exact_to_inexact(num.imag)
+        normalize_number Complex(r, i)
+      when Float, Rational, Integer
+        num.to_f
+      else
+        raise TypeError, "unexpected type of number: #{num.class}"
+      end
+    end
+
+    def normalize_number(num)
+      case num
+      when Complex
+        num.imag.zero? ? num.real : num
+      when Rational
+        num.denominator == 1 ? num.numerator : num
+      else
+        num
+      end
+    end
+  end
+end

data/lib/rubic/version.rb

@@ -1,3 +1,3 @@
 module Rubic
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubic
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - notozeki
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-20 00:00:00.000000000 Z
+date: 2015-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -119,8 +119,10 @@ files:
 - lib/rubic/environment.rb
 - lib/rubic/inspector.rb
 - lib/rubic/interpreter.rb
+- lib/rubic/lexer.rb
 - lib/rubic/parser.rb
 - lib/rubic/parser.y
+- lib/rubic/util.rb
 - lib/rubic/version.rb
 - rubic.gemspec
 homepage: https://github.com/notozeki/rubic