skeem 0.2.12 → 0.2.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d37e901cd3042b1b0b81e29aa885c78bcfd61494e015508687187380be313d5d
-  data.tar.gz: 99918e85f8dafcd9a53465d77dfad99961786bafed16458d3d58eb2a36e39867
+  metadata.gz: 56bd360c4a30ba9dae003a18c922b150924fd0471fe74f1196e75967161ed767
+  data.tar.gz: 90a2af34b4aa7b327656d7f889c94cead17d7a906d5db36e31d7a4ab3af5e920
 SHA512:
-  metadata.gz: e0834459d4d616c84b66ac0e261737388002ba972586a343767ca1f41e5c3d2c52ee31a2367a75362e6b9c9618baf2b69b4feff81fee7e71acd4948900ddb9e1
-  data.tar.gz: 9653c511dd58eabbd15340becadbb4bd23d6bab4cd8ed454e6d98d9e4d304f7837d60775fd40b0528cac252958012a4a7c1c9e3421e3f28074033d21917c7a60
+  metadata.gz: 87827300a4e54068a2e885ef74b5aba42d21d3639a933cb4060b02b39f55b74cc15697098134ca341b1c1bceb6c027c67e1b113de9c10d4455f3b3fed0e0f009
+  data.tar.gz: 3875d43e7c46826a7b6246f5ea07da250401281d54479bb933e0fe73b3da610ac43e1104bdacf975ad658d1ef2834a34a895b24142545cb201b59e028ad5aaa9

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.2.13] - 2019-06-22
+- Skeem now accepts integers in hexadecimal notation
+- Added procedures: `char->integer`, `integer->char`, `char=?`, `char<?`, `char>?`, `char<=?`, `char>=?`
+
+### Changed
+- Class Tokenizer updated to recognize integer literals in hexadecimal notation.
+- `DatumDSL#char(aLiteral): added conversion of char literal into SkmChar.
+- File `grammar.rb` Added a rule to derive a simple datum from a character literal 
+- File `primitive_builder.rb` Implemented primitive procedures `char->integer`, `integer->char`, `char=?`, `char<?`, `char>?`, `char<=?`, `char>=?`
+- File `README.md` Added mentions to new procedures.
+- File `tokenize_spec.rb: added tests for haxadecimal integers.
+- File `primitive_builder_spec.rb`: Added tests for new procedures. 
+
+
 ## [0.2.12] - 2019-06-19
 - Skeem now supports character datatype
 - Added procedures: `boolean=?`, `char?`, `string`, `make-string`, `reverse`

data/README.md

@@ -176,7 +176,7 @@ Here are a few pointers for the Scheme programming language:
 - Of the number hierarchy:  
   `real` (e.g. 2.718, 6.671e-11),  
   `rational` (e.g. 22/7, 1/137, -13/41)  
-  `integer` (42, -3)
+  `integer` (42, -3 also in hexadecimal notation: #x3af)
 - Lists (quoted) : '(1 two "three")
 - Strings: `"Hello, world."`
 - Identifiers (symbols): `really-cool-procedure`
@@ -249,17 +249,17 @@ This section lists the implemented standard procedures
 * `eqv?`, `equal?`
 
 #### Boolean procedures
-* `boolean?`, `and`, `or`,  `not`
+* `boolean?`, `boolean=?`, `and`, `or`,  `not`
 
 #### Character procedures
-* `char?`
+* `char?` `char->integer`, `char=?`, `char<?`, `char>?`,`char<=?`, `char>=?`
 
 #### Numerical operations
 * Number-level: `number?`, `complex?`, `real?`, `rational?`, `integer?`, `zero?`, `exact?`, `inexact?`, `exact-integer?` , `+`, `-`, `*`, `/`,
 `=`, `square`, `number->string`
 * Real-level: `positive?`, `negative?`, `<`, `>`, `<=`, `>=`, `abs`, `max`, `min`,  `floor/`, `floor-quotient`, `floor-remainder`, `truncate/`, `truncate-quotient`,
   `truncate-remainder`, `quotient`, `remainder`, `modulo`, `gcd`, `lcm`, `numerator`, `denominator`, `floor`, `ceiling`, `truncate`, `round`
-* Integer-level: `even?`, `odd?`
+* Integer-level: `even?`, `odd?`, `integer->char`
 
 #### List procedures
 * `list?`, `null?`, `pair?`, `append`, `car`, `cdr`, `caar`, `cadr`, `cdar`, `cddr`,  `cons`,  `length`, `list`, `list-copy`, `list->vector`, `reverse`,  `set-car!`, `set-cdr!`

data/lib/skeem/datum_dsl.rb

@@ -33,7 +33,7 @@ module Skeem
           raise StandardError, aLiteral.inspect
       end
     end
-    
+
     def rational(aLiteral)
       return aLiteral if aLiteral.kind_of?(SkmRational)
 
@@ -45,7 +45,7 @@ module Skeem
         else
           raise StandardError, aLiteral.inspect
       end
-    end    
+    end
 
     def real(aLiteral)
       return aLiteral if aLiteral.kind_of?(SkmReal)
@@ -60,6 +60,23 @@ module Skeem
       end
     end
 
+    def char(aLiteral)
+      return aLiteral if aLiteral.kind_of?(SkmChar)
+
+      result = case aLiteral
+        when Numeric
+          SkmChar.create_from_int(aLiteral)
+        when String
+          value = aLiteral.empty? ? '' : aLiteral.chr
+          SkmChar.create(value)
+        when SkmString
+          value = aLiteral.value.empty? ? '' : aLiteral.value.chr
+          SkmChar.create(value)
+        else
+          raise StandardError, aLiteral.inspect
+      end
+    end
+
     def string(aLiteral)
       return aLiteral if aLiteral.kind_of?(SkmString)
 

data/lib/skeem/grammar.rb

@@ -53,6 +53,7 @@ module Skeem
     rule 'datum' => 'simple_datum'
     rule 'datum' => 'compound_datum'
     rule 'simple_datum' => 'BOOLEAN'
+    rule 'simple_datum' => 'CHAR'
     rule 'simple_datum' => 'number'
     rule 'simple_datum' => 'STRING_LIT'
     rule 'simple_datum' => 'symbol'

data/lib/skeem/primitive/primitive_builder.rb

@@ -95,6 +95,13 @@ module Skeem
 
       def add_char_procedures(aRuntime)
         create_object_predicate(aRuntime, 'char?')
+        create_char2int(aRuntime)
+        create_int2char(aRuntime)
+        create_char_equal(aRuntime)
+        create_char_lt(aRuntime)
+        create_char_gt(aRuntime)
+        create_char_lte(aRuntime)
+        create_char_gte(aRuntime)
       end
 
       def add_string_procedures(aRuntime)
@@ -572,14 +579,89 @@ module Skeem
         end
       end
 
+      # Return true, if all arguments are monotonously increasing
+      def compare_all(first_operand, arglist, operation)
+        if arglist.empty?
+          result = true
+        else
+          result = first_operand.value.send(operation, arglist[0].value)
+          if result
+            arglist.each_cons(2) do |(operand1, operand2)|
+              value1 = operand1.value
+              result &&= value1.send(operation, operand2.value)
+            end
+          end
+        end
+        boolean(result)
+      end
+
       def create_boolean_equal(aRuntime)
         primitive = ->(_runtime, first_operand, arglist) do
-          all_same?(first_operand, arglist)
+          compare_all(first_operand, arglist, :==)
         end
 
         define_primitive_proc(aRuntime, 'boolean=?', one_or_more, primitive)
       end
 
+      def create_char2int(aRuntime)
+        primitive = ->(runtime, arg_evaluated) do
+          check_argtype(arg_evaluated, SkmChar, 'character', 'char->integer')
+          integer(arg_evaluated.value.ord)
+        end
+
+        define_primitive_proc(aRuntime, 'char->integer', unary, primitive)
+      end
+
+      def create_int2char(aRuntime)
+        primitive = ->(runtime, arg_evaluated) do
+          check_argtype(arg_evaluated, SkmInteger, 'integer', 'integer->char')
+          char(arg_evaluated.value.ord)
+        end
+
+        define_primitive_proc(aRuntime, 'integer->char', unary, primitive)
+      end
+
+      def create_char_equal(aRuntime)
+        primitive = ->(_runtime, first_operand, arglist) do
+          compare_all(first_operand, arglist, :==)
+        end
+
+        define_primitive_proc(aRuntime, 'char=?', one_or_more, primitive)
+      end
+
+      def create_char_lt(aRuntime)
+        primitive = ->(_runtime, first_operand, arglist) do
+          compare_all(first_operand, arglist, :<)
+        end
+
+        define_primitive_proc(aRuntime, 'char<?', one_or_more, primitive)
+      end
+
+      def create_char_gt(aRuntime)
+        primitive = ->(_runtime, first_operand, arglist) do
+          compare_all(first_operand, arglist, :>)
+        end
+
+        define_primitive_proc(aRuntime, 'char>?', one_or_more, primitive)
+      end
+
+      def create_char_lte(aRuntime)
+        primitive = ->(_runtime, first_operand, arglist) do
+          compare_all(first_operand, arglist, :<=)
+        end
+
+        define_primitive_proc(aRuntime, 'char<=?', one_or_more, primitive)
+      end
+
+      def create_char_gte(aRuntime)
+        primitive = ->(_runtime, first_operand, arglist) do
+          compare_all(first_operand, arglist, :>=)
+        end
+
+        define_primitive_proc(aRuntime, 'char>=?', one_or_more, primitive)
+      end
+
+
       def create_make_string(aRuntime)
         primitive = ->(runtime, count_arg, arglist) do
           count = count_arg

data/lib/skeem/skm_simple_datum.rb

@@ -152,7 +152,14 @@ module Skeem
   class SkmChar < SkmSimpleDatum
     def char?
       true
-    end  
+    end
+
+    def self.create_from_int(anInteger)
+      int_value = anInteger.kind_of?(SkmInteger) ? anInteger.value : anInteger
+      char_value = int_value < 0xff ? int_value.chr : [int_value].pack('U')
+      create(char_value)
+    end
+
   end # class
 
   class SkmString < SkmSimpleDatum

data/lib/skeem/tokenizer.rb

@@ -93,15 +93,17 @@ module Skeem
         token = build_token(@@lexeme2name[lexeme], lexeme)
       elsif (token = recognize_char_token)
         # Do nothing
-      elsif (lexeme = scanner.scan(/#(?:(?:true)|(?:false)|(?:u8)|[\\\(tfeiodx]|(?:\d+[=#]))/))
-        token = cardinal_token(lexeme)
       elsif (lexeme = scanner.scan(/[+-]?[0-9]+\/[0-9]+(?=\s|[|()";]|$)/))
         token = build_token('RATIONAL', lexeme) # Decimal radix
-      elsif (lexeme = scanner.scan(/[+-]?[0-9]+(?:.0+)?(?=\s|[|()";]|$)/))
+      elsif (lexeme = scanner.scan(/(?:#[dD])?[+-]?[0-9]+(?:.0+)?(?=\s|[|()";]|$)/))
         token = build_token('INTEGER', lexeme) # Decimal radix
+      elsif (lexeme = scanner.scan(/#[xX][+-]?[0-9a-fA-F]+(?=\s|[|()";]|$)/))
+        token = build_token('INTEGER', lexeme) # Hexadecimal radix        
       elsif (lexeme = scanner.scan(/[+-]?[0-9]+(?:\.[0-9]*)?(?:(?:e|E)[+-]?[0-9]+)?/))
         # Order dependency: must be tested after INTEGER case
         token = build_token('REAL', lexeme)
+      elsif (lexeme = scanner.scan(/#(?:(?:true)|(?:false)|(?:u8)|[\\\(tfeiodx]|(?:\d+[=#]))/))
+        token = cardinal_token(lexeme)        
       elsif (lexeme = scanner.scan(/"(?:\\"|[^"])*"/)) # Double quotes literal?
         token = build_token('STRING_LIT', lexeme)
       elsif (lexeme = scanner.scan(/[a-zA-Z!$%&*\/:<=>?@^_~][a-zA-Z0-9!$%&*+-.\/:<=>?@^_~+-]*/))
@@ -136,7 +138,6 @@ Bytevector constants are terminated by ) .
 numbers (section 6.2.5).
 #<n>= #<n># These are used for labeling and referencing
 other literal data (section 2.4).
-        # token = build_token('BOOLEAN', lexeme)
 =end
     def cardinal_token(aLexeme)
       case aLexeme
@@ -210,9 +211,26 @@ other literal data (section 2.4).
     end
 
     def to_integer(aLexeme, aFormat)
-      case aFormat
-      when :default, :base10
-        value = aLexeme.to_i
+      literal = aLexeme.downcase
+      prefix_pattern = /^#[dx]/
+      matching = literal.match(prefix_pattern)
+      if matching
+        case matching[0]
+          when '#d'
+            format = :base10
+          when '#x'
+            format = :base16
+        end
+        literal = matching.post_match
+      else
+        format = :default
+      end
+      
+      case format
+        when :default, :base10
+          value = literal.to_i
+        when :base16
+          value = literal.to_i(16)
       end
 
       value

data/lib/skeem/version.rb

@@ -1,3 +1,3 @@
 module Skeem
-  VERSION = '0.2.12'.freeze
+  VERSION = '0.2.13'.freeze
 end

data/spec/skeem/primitive/primitive_builder_spec.rb

@@ -755,6 +755,96 @@ SKEEM
         end
       end # context
 
+      context 'Character procedures:' do
+        it 'should implement the char? procedure' do
+          checks = [
+            ['(char? #f)', false],
+            ["(char? 'a)", false],
+            ['(char? #\a)', true],
+            ['(char? "a")', false],
+            ["(char? '(#\\a 1))", false]
+          ]
+          compare_to_predicted(checks)
+        end
+
+        it 'should implement the char->integer procedure' do
+          checks = [
+            ['(char->integer #\space)', 0x20],
+            ['(char->integer #\newline)', 0x0a],
+            ['(char->integer #\a)', ?a.ord],
+            ['(char->integer #\x05a)', 0x5a]
+          ]
+          compare_to_predicted(checks)
+        end
+
+        it 'should implement the integer->char procedure' do
+          checks = [
+            ['(integer->char #x20)', ?\s],
+            ['(integer->char 48)', ?0],
+            ['(integer->char #x0a)', ?\n],
+            ['(integer->char #x3bb)', ?\u03bb]
+          ]
+          compare_to_predicted(checks)
+        end
+
+        it 'should implement the char=? procedure' do
+          checks = [
+            ['(char=? #\a)', true],
+            ['(char=? #\a #\a)', true],
+            ['(char=? #\a #\b)', false],
+            ['(char=? #\space #\space #\space)', true],
+            ['(char=? #\space #\space #\newline)', false]
+          ]
+          compare_to_predicted(checks)
+        end
+
+        it 'should implement the char<? procedure' do
+          checks = [
+            ['(char<? #\a)', true],
+            ['(char<? #\a #\a)', false],
+            ['(char<? #\a #\b)', true],
+            ['(char<? #\a #\b #\c)', true],
+            ['(char<? #\a #\c #\b)', false]
+          ]
+          compare_to_predicted(checks)
+        end
+
+        it 'should implement the char>? procedure' do
+          checks = [
+            ['(char>? #\b)', true],
+            ['(char>? #\b #\b)', false],
+            ['(char>? #\b #\a)', true],
+            ['(char>? #\c #\b #\a)', true],
+            ['(char>? #\c #\a #\b)', false]
+          ]
+          compare_to_predicted(checks)
+        end
+
+        it 'should implement the char<=? procedure' do
+          checks = [
+            ['(char<=? #\a)', true],
+            ['(char<=? #\a #\a)', true],
+            ['(char<=? #\b #\a)', false],
+            ['(char<=? #\a #\b #\c)', true],
+            ['(char<=? #\a #\c #\c)', true],
+            ['(char<=? #\a #\c #\b)', false]
+          ]
+          compare_to_predicted(checks)
+        end
+
+        it 'should implement the char>=? procedure' do
+          checks = [
+            ['(char>=? #\a)', true],
+            ['(char>=? #\a #\a)', true],
+            ['(char>=? #\a #\b)', false],
+            ['(char>=? #\c #\b #\a)', true],
+            ['(char>=? #\c #\b #\b)', true],
+            ['(char>=? #\c #\a #\b)', false]
+          ]
+          compare_to_predicted(checks)
+        end
+      end # context
+
       context 'Vector procedures:' do
         it 'should implement the vector? procedure' do
           checks = [

data/spec/skeem/tokenizer_spec.rb

@@ -80,6 +80,33 @@ module Skeem
 
         check_tokens(tests, 'INTEGER')
       end
+      
+      it 'should tokenize integers with explicit radix 10' do
+        tests = [
+          # couple [raw input, expected]
+          ['#d0', 0],
+          ['#D3', 3],
+          ['#d+3 ', +3],
+          ['#D-3', -3],
+          ['#d-3.0', -3],
+          ['#D-1234', -1234]
+        ]
+
+        check_tokens(tests, 'INTEGER')
+      end
+
+      it 'should tokenize integers in hexadecimal notation' do
+        tests = [
+          # couple [raw input, expected]
+          ['#x0', 0],
+          ['#Xf', 0xf],
+          ['#x+F ', 0xf],
+          ['#X-f', -0xf],
+          ['#X-12Ac', -0x12ac]
+        ]
+
+        check_tokens(tests, 'INTEGER')
+      end      
     end # context
 
     context 'Rational literals recognition:' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skeem
 version: !ruby/object:Gem::Version
-  version: 0.2.12
+  version: 0.2.13
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-19 00:00:00.000000000 Z
+date: 2019-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley