nendo 0.6.5 → 0.6.6

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    Nzk3MjcxOGM4OGYxOWMwYWIxMDBiNGZjZDg0OGYwNTNkNzcwZjA4Mg==
+    YTBkYzNiM2M2Yzk1ZWMzNTRmMTAxZTdmMTljNjMyNWM4Y2U5Njc2ZA==
   data.tar.gz: !binary |-
-    MTU2Y2I0MzFkMjQ1YjU4OTdiYzFmMThhYjZjNWVlNzgyYWQ0OGE5Zg==
+    NjZiZjljYzk3YTk3Y2U3YTJkNTcxNjVlZTNmZTYxNTE3ZWQzYTVmNQ==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    ZmMwOWIzZWUyYjA5NzJkYzM1NjQwODdlOWIwYTk3M2EwNzYxODhlYmY3YWY4
-    YzJkMzFiMTVmMmFjMWM0MjUzMTMzNWZmMzFkYzQ0Njg1MTM2NDBjMzE2NDRj
-    MzhhYmY0MjczMTcyYWM5NDM4YTVlMDMyZmRhZmYyZjgzNTdiYzg=
+    YzA4YzA1N2NmMjI4YWQwNDkyYjNlYTJhZWJjMzFiOTBjYzY4NmI4YTJlY2U2
+    ODkyMjdhYzJhZGQ0ZjZjM2M2NmUxOGI3NjdkOGJiZGJmOWE3NjUwYTM0NTUz
+    YzBlZGZkNDM1NDFlOWNlZWFhZjgzOGZjYjRjOTMxYjQyNzUyNzI=
   data.tar.gz: !binary |-
-    NjA5MjZhY2VjMjExY2JlNTM2OTc1ZDllOWY2ZmIxNGNmMTIzNzkzZWI1ZTYx
-    OTcwZDlmMDdmMzkyYjcxOGZiMmNmOGQzYjRkZmExYTljMTYxNTg0MWZlNTA5
-    NTQ4MDQ0MjU3NjhmMjRiMjAxYjQ5ODEwMWJlMjEyZDY0NDFhYmU=
+    NjM3ODhmZGYyMzMyNzUwOWVjZTU4OTY1ZmQ0YmU4MDFiYmRhOWYxMTA1YzAw
+    ZmRkODRmMzc0MWQwNTBkN2IxY2RjODQ1NzMwNTMxZGUwNGQwYWE5YjBiODM4
+    M2FiYTZjZTM1OGQ3MWZhMDBkMzllODJiYWMyMjYyMjMwMmViZDU=

data/README.md

@@ -0,0 +1,13 @@
+Nendo
+=======================
+
+Nendo is a dialect of Lisp written in Ruby.
+
+This software is open source, covered by a BSD-style license. Please read accompanying file COPYING.
+
+## Link
+  [Manuals and Tutorials](http://oldtype.sumibi.org/show-page/Nendo)
+
+
+
+

data/Rakefile

@@ -3,7 +3,7 @@
 # Release Engineering
 #   1. edit the VERSION.yml file
 #   2. rake compile  &&   rake
-#   3. rake gemspec  &&   rake build
+#   3. rake gemspec  &&   gem build nendo.gemspec
 #      to generate nendo-x.x.x.gem
 #   4. install nendo-x.x.x.gem to clean environment and test
 #   5. rake release
@@ -17,13 +17,14 @@ begin
     gemspec.summary = "Nendo is a dialect of Lisp."
     gemspec.description = "Nendo is a programming language written in Ruby."
     gemspec.email = "kiyoka@sumibi.org"
+    gemspec.license = 'New BSD'
     gemspec.homepage = "http://github.com/kiyoka/nendo"
     gemspec.authors = ["Kiyoka Nishiyama"]
     gemspec.files = FileList['Rakefile',
                              '.gemtest',
                              'History.txt',
                              'VERSION.yml',
-                             'README',
+                             'README.md',
                              'COPYING',
                              'lib/**/*.rb',
                              'lib/**/*.nnd',
@@ -38,6 +39,7 @@ begin
                              'emacs/*.el',
                              'benchmark/*.rb',
                              'benchmark/*.nnd'].to_a
+    gemspec.rdoc_options += [ '-x', 'match.nndc' ]
     gemspec.add_development_dependency "rspec"
     gemspec.add_development_dependency "rake"
     gemspec.add_dependency             "json"
@@ -132,7 +134,7 @@ task :compile do
   files << "./lib/nendo/util/combinations.nnd"
   files << "./lib/nendo/nendo/experimental.nnd"
   files.each {|fn|
-    sh sprintf( "ruby -I ./lib ./bin/nendo -c %s > %s", fn, fn + "c" )
+    sh sprintf( "ruby -I ./lib ./bin/nendo -d -c %s > %s", fn, fn + "c" )
   }
 end
 

data/VERSION.yml

@@ -1,4 +1,4 @@
 ---
 :major: 0
 :minor: 6
-:patch: 5
+:patch: 6

data/benchmark/benchmark.nnd

@@ -11,22 +11,30 @@
     (require "jruby-prof")
     (require "ruby-prof"))
 
+(define results '())
+(define (bench-puts str)
+  #t)
+(define (bench-printf format str)
+  #t)
+
 ;; ------------------ macro --------------------
 (define bench-task
   (macro (profile-flag title proc)
     `(begin
-       (.puts ,title)
-       (.puts Benchmark::CAPTION)
+       (bench-puts ,title)
+       (bench-puts Benchmark::CAPTION)
        ,(if profile-flag
             `(let* ((result (RubyProf.profile
                              (&block ()
                                ,proc)))
                     (printer (RubyProf::GraphPrinter.new result)))
                (printer.print STDOUT))
-            `(.puts (Benchmark.measure
-                     (&block ()
-                       ,proc))))
-       (.puts ""))))
+            `(let1 str (Benchmark.measure
+                        (&block ()
+                          ,proc))
+               (push! results (cons ,title str))
+               (bench-puts str)))
+       (bench-puts ""))))
 
 (define ten-times
   (macro (expr)
@@ -43,96 +51,103 @@
 ;; -------------------- fact --------------------
 (bench-task #f
             "fact (ruby version)"
-            (printf " => %d\n" (RubyBenchmarkCode.new.fact 100)))
+            (bench-printf " => %d\n" (RubyBenchmarkCode.new.fact 100)))
 
 (bench-task #f
             "fact (nendo version)"
-            (printf " => %d\n" (fact 100)))
+            (bench-printf " => %d\n" (fact 100)))
 
 
 ;; -------------------- plus --------------------
 (for-each
  (lambda (level)
    (set-optimize-level level)
-   (printf " --- optimize level %d ---\n" level)
+   (bench-printf " --- optimize level %d ---\n" level)
    (bench-task #f
                "+ 0arg (nendo version)"
-               (printf " => %d\n" (hundled-times (plus0))))
+               (bench-printf " => %d\n" (hundled-times (plus0))))
    
    (bench-task #f
                "+ 1arg (nendo version)"
-               (printf " => %d\n" (hundled-times (plus1))))
+               (bench-printf " => %d\n" (hundled-times (plus1))))
    
    (bench-task #f
                "+ 2arg (nendo version)"
-               (printf " => %d\n" (hundled-times (plus2))))
+               (bench-printf " => %d\n" (hundled-times (plus2))))
    
    (bench-task #f
                "+ 3arg (nendo version)"
-               (printf " => %d\n" (hundled-times (plus3)))))
+               (bench-printf " => %d\n" (hundled-times (plus3)))))
  '(1 2))
 (print "--------------------")
 
 ;; -------------------- tak --------------------
 (bench-task #f
             "tak   (ruby version)"
-            (printf " => %d\n" (RubyBenchmarkCode.new.tak  10 5 0)))
+            (bench-printf " => %d\n" (RubyBenchmarkCode.new.tak  10 5 0)))
 
 (bench-task #f
             "tak2  (ruby version)"
-            (printf " => %d\n" (RubyBenchmarkCode.new.tak2 10 5 0)))
+            (bench-printf " => %d\n" (RubyBenchmarkCode.new.tak2 10 5 0)))
 
 (bench-task #f
             "tak3  (ruby version)"
-            (printf " => %d\n" (RubyBenchmarkCode.new.tak3 10 5 0)))
+            (bench-printf " => %d\n" (RubyBenchmarkCode.new.tak3 10 5 0)))
 
 (bench-task #f
             "tak   (nendo version)"
-            (printf " => %d\n" (tak 10 5 0)))
+            (bench-printf " => %d\n" (tak 10 5 0)))
 
 ;; -------------------- higher-order --------------------
-(let ([list10000 (range 10000)])
+(let ([list100000 (range 100000)])
 
   (bench-task #f
-            "for-each  10000 (nendo version)"
+            "for-each  100000 (nendo version)"
             (for-each
              (lambda (x) (+ 1 x))
-             list10000))
+             list100000))
 
   (bench-task #f
-            "map       10000 (nendo version)"
+            "map       100000 (nendo version)"
             (map
              (lambda (x) (+ 1 x))
-             list10000))
+             list100000))
 
   (bench-task #f
-            "filter    10000 (nendo version)"
+            "filter    100000 (nendo version)"
             (filter
              (lambda (x) (if (< x 100) x false))
-             list10000)))
+             list100000)))
                
 ;; ------------- higher-order for vector ----------------
 
 (use nendo.experimental)
 
-(let ([vec10000 (to-arr (range 10000)]])
+(let ([vec100000 (to-arr (range 100000)]])
   (bench-task #f
-              "for-each  vector 10000 (nendo version)"
+              "for-each  vector 100000 (nendo version)"
               (for-each
                (lambda (x) (+ 1 x))
-               vec10000))
+               vec100000))
 
   (bench-task #f
-              "map       vector 10000 (nendo version)"
+              "map       vector 100000 (nendo version)"
               (map
                (lambda (x) (+ 1 x))
-               vec10000))
+               vec100000))
   
   (bench-task #f
-              "filter    vector 10000 (nendo version)"
+              "filter    vector 100000 (nendo version)"
               (filter
                (lambda (x) (if (< x 100) x false))
-               vec10000))
+               vec100000))
   )
 
+;; ----- print results -------
+(print "-------------------- results --------------------")
+(for-each
+ (lambda (x)
+   (printf "%40s\t%s" (car x) (cdr x)))
+ (reverse results))
+
 ;;[EOF]

data/bin/nendo

@@ -50,6 +50,8 @@ def userOptionEater
       i += 1
     when '-V'
       i += 1
+    when '-d'
+      i += 1
     when '-l'
       i += 2
     when '-O'
@@ -79,6 +81,7 @@ def main
                         [ '-q', GetoptLong::NO_ARGUMENT ],
                         [ '-c', GetoptLong::NO_ARGUMENT ],
                         [ '-V', GetoptLong::NO_ARGUMENT ],
+                        [ '-d', GetoptLong::NO_ARGUMENT ],
                         [ '-l', GetoptLong::REQUIRED_ARGUMENT ],
                         [ '-O', GetoptLong::REQUIRED_ARGUMENT ]
                         ).each { |opt, arg|
@@ -106,6 +109,9 @@ def main
       -O:
         set optimize level. (0:no optimize,   1:tail call optimize)
 
+      -d:
+        disable runtime check.
+
       EOF
       exit 0
     when '-V'
@@ -123,6 +129,8 @@ def main
       STDERR.printf( "loaded file [%s]\n", arg )
     when '-O'
       core.setOptimizeLevel( arg.to_i )
+    when '-d'
+      core.disableRuntimeCheck( )
     end
   }
 

data/lib/nendo/debug/syslog.nndc

@@ -5,13 +5,9 @@
 
 trampCall( 
   begin
-    embedBacktraceInfo( "./lib/nendo/debug/syslog.nnd", 37 ); 
       delayCall( '_require',  'require',
           begin
-            if @global_lisp_binding.has_key?('_require') then
               trampCall(@_require)
-            else raise NameError.new( "Error: undefined variable _require", "_require" ) end
-            rescue => __e ; __e.set_backtrace( ["./lib/nendo/debug/syslog.nnd:37"] + __e.backtrace ) ; raise __e
           end        ,
       [
           "syslog"
@@ -31,32 +27,26 @@ trampCall(
               begin
                   trampCall(Syslog).open(
                     )
-                rescue => __e ; __e.set_backtrace( ["./lib/nendo/debug/syslog.nnd:40"] + __e.backtrace ) ; raise __e
               end
               begin
                   trampCall(Syslog).log(
                         begin
                             trampCall(Syslog::LOG_WARNING)
-                          rescue => __e ; __e.set_backtrace( ["./lib/nendo/debug/syslog.nnd:41"] + __e.backtrace ) ; raise __e
                         end                      ,
                       "%s"                      ,
                         begin
-                          embedBacktraceInfo( "./lib/nendo/debug/syslog.nnd", 41 ); 
                             __PLMARK_ARGS2(
                               "Nendo: "                              ,
                                 begin
                                     trampCall(_str)
-                                  rescue => __e ; __e.set_backtrace( ["./lib/nendo/debug/syslog.nnd:41"] + __e.backtrace ) ; raise __e
                                 end
                             )
                         end
                     )
-                rescue => __e ; __e.set_backtrace( ["./lib/nendo/debug/syslog.nnd:41"] + __e.backtrace ) ; raise __e
               end
               begin
                   trampCall(Syslog).close(
                     )
-                rescue => __e ; __e.set_backtrace( ["./lib/nendo/debug/syslog.nnd:42"] + __e.backtrace ) ; raise __e
               end
           }
     )