rus3 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dfda189d1f2499f00d441efe70f0e8db49ecc443a8c414ec7b4f9282caf28fe2
-  data.tar.gz: 1a0c858ec768aec68e79b66815fd8b5cdd2c6eef2f4e688e55f90fbcd1fde558
+  metadata.gz: e00bc6347634a3d6fd3ee9da17b18334e49373bab389c9c0126e5ee983504b56
+  data.tar.gz: 369f1e8627bdcb5c8ece22d0ba4971b417fa4924fa67ca31da3665bebb6a3aa8
 SHA512:
-  metadata.gz: cb42c290cdcea8dacd9ae0b024ce0c2b266ae912ddc4178c40c5134fda5a79507d420ab959fc10a9860dd8bf3d805e16347a9cd791c4e90ddffaf1e7afd29932
-  data.tar.gz: 16450eb77a484889dc5572a62fd48670b278fac5f4845111d6b192dbf8820bac54854a150a628004b9461b995a166f1957876d72636b732b11cf7c6db3dbc6c6
+  metadata.gz: 4eac508d23d36f6f1f7f6b60879bfbb80921c16ed669ed2d60e5d4d8926a62189269c8cef2373e6489d3dae3b47af01ee888116ecd8a85070f84ce3c8493e57a
+  data.tar.gz: ac9f76be872b9a5d70822f4bf0d4fab3da83d931002fd2f7b749648f704e65b7063487f9e9d095630a8c5bb8e9dd2f3e3b24fef3f24338d83e49cc73404a603c

data/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 ## [Unreleased]
 - (nothing to record)
 
+## [0.1.2] - 2021-04-23
+### Added
+- Add `char`:
+  - add Rus3::Char class,
+  - modify Rus3::Parser::Lexer to accept a character literal,
+  - modify Rus3::Parser::SchemeParser to parse and translate a
+    character literal,
+- Add new error classes (CharRequiredError),
+- Add tests around `char`.
+
 ## [0.1.1] - 2021-04-22
 ### Added
 - Add `vector`:

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rus3 (0.1.1)
+    rus3 (0.1.2)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -54,6 +54,11 @@ Rus3(scheme)> 3+4i
 ==> (3+4i)
 Rus3(scheme)> #(1 2 3)
 ==> #<Rus3::Vector:0x00007facf12d9fb0 @content=[1, 2, 3]>
+Rus3(scheme)> #\a
+==> #<Rus3::Char:0x00007fc41f1059d8
+ @char="a",
+ @codepoint=97,
+ @encoding=#<Encoding:UTF-8>>
 ```
 
 ### Procedure call
@@ -117,14 +122,18 @@ Following procedures described in the spec is available.
 - Predicates:
   - null?, list?
   - eqv?, eq?
-  - boolean?, pair?, symbol?, number?, string?, vector?
-    - char? and port? are defined but it always returns `false`.
+  - boolean?, pair?, symbol?, number?, string?, vector?, char?
+    - port? are defined but it always returns `false`.
   - complex?, real?, rational?, integer?
   - zero?, positive?, negative?, odd?, even?
   - string-eq?, string-ci-eq?, string-lt?, string-gt?, string-le?,
     string-ge?, string-ci-lt?, string-ci-gt?, string-ci-le?, string-ci-ge?
-  - some predicates for `char` and `port` are defined but it always
-    returns `false`.
+  - char-eq?, char-lt?, char-gt?, char-le?, char-ge?,
+    char-ci-eq?, char-ci-lt?, char-ci-gt?, char-ci-le?, char-ci-ge?,
+	char-alphabetic?, char-numeric?, char-whitespace?,
+	char-upper-case?, char-lower-case?
+  - some predicates for `port` are defined but it always returns
+    `false`.
 
 - List operations
   - cons, car, cdr, set-car!, set-cdr!, cxxr (caar and so on)
@@ -134,6 +143,9 @@ Following procedures described in the spec is available.
   - make-vector, vector, vector-length, vector-ref, vector-set!,
     vector->list, list->vector, vector-fill!
 
+- Char operations
+  - char->integer, integer->char, char-upcase, char-downcase
+
 - Write values
   - write
   - display
@@ -169,6 +181,7 @@ deviations from the Scheme specification (R5RS or R7RS-small).
   identifier in Ruby.  So, it is possible that some collision of
   identifiers.
 - Nested definition of procedure can use outside.
+- All characters and strings are treated as encoded in UTF-8.
 
 Some of these may be disappeared in the future version, or may not be.
 

data/lib/rus3.rb

@@ -43,6 +43,7 @@ module Rus3
 
   require_relative "rus3/procedure/utils"
   require_relative "rus3/procedure/predicate"
+  require_relative "rus3/procedure/char"
   require_relative "rus3/procedure/list"
   require_relative "rus3/procedure/vector"
   require_relative "rus3/procedure/control"

data/lib/rus3/char.rb

@@ -1,6 +1,102 @@
 # frozen_string_literal: true
 
 module Rus3
+
   class Char
+    include Comparable
+
+    class << self
+
+      def alphabetic?(char)
+        raise CharRequiredError, char unless char.instance_of?(Char)
+        /[A-Za-z]/ === char.to_s
+      end
+
+      def numeric?(char)
+        raise CharRequiredError, char unless char.instance_of?(Char)
+        /[0-9]/ === char.to_s
+      end
+
+      def whitespace?(char)
+        raise CharRequiredError, char unless char.instance_of?(Char)
+        /[\s]/ === char.to_s
+      end
+
+      def upper_case?(char)
+        raise CharRequiredError, char unless char.instance_of?(Char)
+        /[A-Z]/ === char.to_s
+      end
+
+      def lower_case?(char)
+        raise CharRequiredError, char unless char.instance_of?(Char)
+        /[a-z]/ === char.to_s
+      end
+
+      def char_to_integer(char)
+        raise CharRequiredError, char unless char.instance_of?(Char)
+        char.codepoint
+      end
+
+      def integer_to_char(n, encoding: Encoding::UTF_8)
+        self.new(n.chr(encoding))
+      end
+
+      def upcase(char)
+        raise CharRequiredError, char unless char.instance_of?(Char)
+        self.new(char.to_s.upcase)
+      end
+
+      def downcase(char)
+        raise CharRequiredError, char unless char.instance_of?(Char)
+        self.new(char.to_s.downcase)
+      end
+
+      def compare_chars(char1, char2, comp_op, ignore_case: false)
+        if !char1.instance_of?(self)
+          raise CharRequiredError, char1
+        elsif !char2.instance_of?(self)
+          raise CharRequiredError, char2
+        end
+
+        if ignore_case
+          char1 = downcase(char1)
+          char2 = downcase(char2)
+        end
+        char1.send(comp_op, char2)
+      end
+
+    end
+
+    LITERAL_PREFIX  = "#\\"
+    LITERAL_SPACE   = "#\\space"
+    LITERAL_NEWLINE = "#\\newline"
+
+    attr_reader :codepoint
+    attr_reader :encoding
+
+    def initialize(str)
+      @char = str[0].dup.freeze
+      @encoding = str.encoding
+      @codepoint = @char.ord
+    end
+
+    def ==(other)
+      other.instance_of?(Char) and to_s == other.to_s
+    end
+
+    def <=>(other)
+      raise CharRequiredError, other unless other.instance_of?(Char)
+      @codepoint <=> other.codepoint
+    end
+
+    def to_literal
+      LITERAL_PREFIX + @char
+    end
+
+    def to_s
+      @char
+    end
+
   end
+
 end

data/lib/rus3/error.rb

@@ -30,95 +30,96 @@ module Rus3
   # :stopdoc:
 
   EMSG = {
+    :number_required => "number required: got=%s",
+    :integer_required => "integer required: got=%s",
+    :real_number_required => "real number required: got=%s",
+    :char_required => "char required: got=%s",
+    :string_required => "string required: got=%s",
+    :vector_required => "vector required: got=%s",
     :pair_required => "pair required: got=%s",
     :list_required => "proper list required: got=%s",
     :pair_or_list_required => "pair or proper list required: got=%s",
-    :vector_required => "vector required: got=%s",
     :out_of_range  => "argument out of range: got=%s",
     :exceed_upper_limit => "argument exceeds its upper limit (%d): got=%d",
-    :unsupported_method => "specified method does not work now.",
     :wrong_type => "wrong type argument: got=%s, wants=%s",
-    :integer_required => "integer required: got=%s",
-    :real_number_required => "real number required: got=%s",
-    :number_required => "number required: got=%s",
-    :string_required => "string required: got=%s",
     :scheme_syntax_error => "syntax error as Scheme: got=%s",
+    :unsupported_method => "specified method does not work now.",
+    :unsupported_feature => "specified feature (`%s`) does not support for %s",
     :cannot_find_file => "cannot find %s",
-    :unsupported_feature => "specified feature (`%s`) does not support for %s"
   }
 
   # :startdoc:
 
-  class PairRequiredError < Error
+  class NumberRequiredError < Error
     def initialize(obj)
-      super(EMSG[:pair_required] % smart_error_value(obj))
+      super(EMSG[:number_required] % smart_error_value(obj))
     end
   end
 
-  class ListRequiredError < Error
+  class IntegerRequiredError < Error
     def initialize(obj)
-      super(EMSG[:list_required] % smart_error_value(obj))
+      super(EMSG[:integer_required] % smart_error_value(obj))
     end
   end
 
-  class PairOrListRequiredError < Error
+  class RealNumberRequiredError < Error
     def initialize(obj)
-      super(EMSG[:pair_or_list_required] % smart_error_value(obj))
+      super(EMSG[:real_number_required] % smart_error_value(obj))
     end
   end
 
-  class VectorRequiredError < Error
+  class CharRequiredError < Error
     def initialize(obj)
-      super(EMSG[:vector_required] % smart_error_value(obj))
+      super(EMSG[:char_required] % smart_error_value(obj))
     end
   end
 
-  class OutOfRangeError < Error
+  class StringRequiredError < Error
     def initialize(obj)
-      super(EMSG[:out_of_range] % smart_error_value(obj))
+      super(EMSG[:string_required] % smart_error_value(obj))
     end
   end
 
-  class ExceedUpperLimitError < Error
-    def initialize(value, limit)
-      super(EMSG[:exceed_upper_limit] % [limit, value])
+  class VectorRequiredError < Error
+    def initialize(obj)
+      super(EMSG[:vector_required] % smart_error_value(obj))
     end
   end
 
-  class UnsupportedMethodError < Error
-    def initialize
-      super(EMSG[:unsupported_method])
+  class PairRequiredError < Error
+    def initialize(obj)
+      super(EMSG[:pair_required] % smart_error_value(obj))
     end
   end
 
-  class WrongTypeError < Error
-    def initialize(obj, expected)
-      emsg = EMSG[:wrong_type] % [obj, expected]
-      super(emsg)
+  class ListRequiredError < Error
+    def initialize(obj)
+      super(EMSG[:list_required] % smart_error_value(obj))
     end
   end
 
-  class IntegerRequiredError < Error
+  class PairOrListRequiredError < Error
     def initialize(obj)
-      super(EMSG[:integer_required] % smart_error_value(obj))
+      super(EMSG[:pair_or_list_required] % smart_error_value(obj))
     end
   end
 
-  class RealNumberRequiredError < Error
+  class OutOfRangeError < Error
     def initialize(obj)
-      super(EMSG[:real_number_required] % smart_error_value(obj))
+      super(EMSG[:out_of_range] % smart_error_value(obj))
     end
   end
 
-  class NumberRequiredError < Error
-    def initialize(obj)
-      super(EMSG[:number_required] % smart_error_value(obj))
+  class ExceedUpperLimitError < Error
+    def initialize(value, limit)
+      super(EMSG[:exceed_upper_limit] % [limit, value])
     end
   end
 
-  class StringRequiredError < Error
-    def initialize(obj)
-      super(EMSG[:string_required] % smart_error_value(obj))
+  class WrongTypeError < Error
+    def initialize(obj, expected)
+      emsg = EMSG[:wrong_type] % [obj, expected]
+      super(emsg)
     end
   end
 
@@ -128,9 +129,9 @@ module Rus3
     end
   end
 
-  class CannotFindFileError < Error
-    def initialize(obj)
-      super(EMSG[:cannot_find_file] % smart_error_value(obj))
+  class UnsupportedMethodError < Error
+    def initialize
+      super(EMSG[:unsupported_method])
     end
   end
 
@@ -140,4 +141,10 @@ module Rus3
     end
   end
 
+  class CannotFindFileError < Error
+    def initialize(obj)
+      super(EMSG[:cannot_find_file] % smart_error_value(obj))
+    end
+  end
+
 end

data/lib/rus3/evaluator.rb

@@ -16,6 +16,7 @@ module Rus3
       include Rus3::Procedure::Write
       include Rus3::Procedure::Vector
       include Rus3::Procedure::List
+      include Rus3::Procedure::Char
       include Rus3::Procedure::Predicate
       include Rus3::EmptyList
 

data/lib/rus3/parser/lexer.rb

@@ -17,6 +17,7 @@ module Rus3::Parser
       # value types
       :boolean,
       :ident,
+      :char,
       :string,
       :number,
       # operators
@@ -55,6 +56,15 @@ module Rus3::Parser
     COMPLEX    = Regexp.new("\\A[+-]?#{COMP_PAT}\\Z")
     PURE_IMAG  = Regexp.new("\\A[+-](#{C_IMAG_PAT})?i\\Z")
 
+    # char
+    SINGLE_CHAR_PAT = "."
+    SPACE_PAT       = "space"
+    NEWLINE_PAT     = "newline"
+
+    CHAR_PREFIX = "\#\\\\"
+    CHAR_PAT    = "(#{SINGLE_CHAR_PAT}|#{SPACE_PAT}|#{NEWLINE_PAT})"
+    CHAR        = Regexp.new("\\A#{CHAR_PREFIX}#{CHAR_PAT}\\Z")
+
     KEYWORDS = {
       "LAMBDA" => :lambda,
       "IF"     => :if,
@@ -102,6 +112,8 @@ module Rus3::Parser
             else
               Token.new(:ident, literal.gsub(EXTENDED_REGEXP, EXTENDED_MAP))
             end
+          when CHAR
+            Token.new(:char, literal)
           when STRING
             Token.new(:string, literal)
           when "="

data/lib/rus3/parser/scheme_parser.rb

@@ -155,7 +155,7 @@ module Rus3::Parser
         r_exp = translate_ident(token.literal)
       when :string
         r_exp = token.literal
-      when :ident, :boolean, :number, :op_proc
+      when :ident, :boolean, :char, :number, :op_proc
         trans_method_name = "translate_#{token.type}".intern
         r_exp = self.send(trans_method_name, token.literal)
       else
@@ -213,6 +213,17 @@ module Rus3::Parser
       (s_exp_literal[1] == "f") ? "false" : "true"
     end
 
+    def translate_char(s_exp_literal)
+      c = s_exp_literal[2..-1]
+      case c
+      when "space"
+        c = " "
+      when "newline"
+        c = "\n"
+      end
+      "Char.new(\"#{c}\")"
+    end
+
     def translate_number(s_exp_literal)
       if s_exp_literal.include?("/") # rational?
         denominator, numerator = s_exp_literal.split("/").map{|s| Kernel.eval(s)}

data/lib/rus3/procedure/char.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Rus3::Procedure
+  module Char
+
+    #   - procedure (R5RS): (char->integer char)
+
+    def char_to_integer(char)
+      Rus3::Char.char_to_integer(char)
+    end
+
+    #   - procedure (R5RS): (integer->char n)
+
+    def integer_to_char(n)
+      Rus3::Char.integer_to_char(n)
+    end
+
+    #   - library procedure (R5RS): (char-upcase char)
+
+    def char_upcase(char)
+      Rus3::Char.upcase(char)
+    end
+
+    #   - library procedure (R5RS): (char-downcase char)
+
+    def char_downcase(char)
+      Rus3::Char.downcase(char)
+    end
+
+  end
+end

data/lib/rus3/procedure/predicate.rb

@@ -72,7 +72,7 @@ module Rus3::Procedure
     end
 
     def char?(obj)
-      false
+      obj.instance_of?(Rus3::Char)
     end
 
     def string?(obj)
@@ -163,69 +163,67 @@ module Rus3::Procedure
     # :stopdoc:
 
     # Characters:
-    #
-    # ...
 
     # :startdoc:
 
     def char_eq?(char1, char2)
-      false
+      Rus3::Char.compare_chars(char1, char2, :==)
     end
 
     def char_lt?(char1, char2)
-      false
+      Rus3::Char.compare_chars(char1, char2, :<)
     end
 
     def char_gt?(char1, char2)
-      false
+      Rus3::Char.compare_chars(char1, char2, :>)
     end
 
     def char_le?(char1, char2)
-      false
+      Rus3::Char.compare_chars(char1, char2, :<=)
     end
 
     def char_ge?(char1, char2)
-      false
+      Rus3::Char.compare_chars(char1, char2, :>=)
     end
 
     def char_ci_eq?(char1, char2)
-      false
+      Rus3::Char.compare_chars(char1, char2, :==, ignore_case: true)
     end
 
     def char_ci_lt?(char1, char2)
-      false
+      Rus3::Char.compare_chars(char1, char2, :<, ignore_case: true)
     end
 
     def char_ci_gt?(char1, char2)
-      false
+      Rus3::Char.compare_chars(char1, char2, :>, ignore_case: true)
     end
 
     def char_ci_le?(char1, char2)
-      false
+      Rus3::Char.compare_chars(char1, char2, :<=, ignore_case: true)
     end
 
     def char_ci_ge?(char1, char2)
-      false
+      Rus3::Char.compare_chars(char1, char2, :>=, ignore_case: true)
     end
 
     def char_alphabetic?(char)
-      false
+      Rus3::Char.alphabetic?(char)
     end
 
     def char_numeric?(char)
-      false
+      Rus3::Char.numeric?(char)
     end
 
     def char_whitespace?(char)
-      false
+      Rus3::Char.whitespace?(char)
     end
 
     def char_upper_case?(letter)
-      false
+      Rus3::Char.upper_case?(letter)
     end
 
     def char_lower_case?(letter)
-      false
+      Rus3::Char.lower_case?(letter)
     end
 
     # :stopdoc:

data/lib/rus3/repl.rb

@@ -75,7 +75,7 @@ module Rus3
         begin
           exp = @parser.read(STDIN)     # READ
         rescue SchemeSyntaxError => e
-          puts "ERROR: %s" % e
+          puts "ERROR" + (@verbose ? "(READ)" : "")  + ": %s" % e
           next
         end
         break FAREWELL_MESSAGE if exp.nil?
@@ -83,7 +83,7 @@ module Rus3
         begin
           value = @evaluator.eval(exp)  # EVAL
         rescue SyntaxError, StandardError => e
-          puts "ERROR: %s" % e
+          puts "ERROR" + (@verbose ? "(EVAL)" : "")  + ": %s" % e
           next
         end
 

data/lib/rus3/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Rus3
-  VERSION = "0.1.1"
-  RELEASE = "2021-04-22"
+  VERSION = "0.1.2"
+  RELEASE = "2021-04-23"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rus3
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - mnbi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-04-22 00:00:00.000000000 Z
+date: 2021-04-23 00:00:00.000000000 Z
 dependencies: []
 description: Ruby with Syntax Sugar of Scheme
 email:
@@ -42,6 +42,7 @@ files:
 - lib/rus3/parser/scheme_parser.rb
 - lib/rus3/port.rb
 - lib/rus3/printer.rb
+- lib/rus3/procedure/char.rb
 - lib/rus3/procedure/control.rb
 - lib/rus3/procedure/list.rb
 - lib/rus3/procedure/predicate.rb