statsailr 0.7.1 → 0.7.5

data/lib/statsailr/scanner/sts_scanner.rb

@@ -9,49 +9,8 @@ SQ_STR_PATTERN = /'(\\'|[^'\n])*'/
 DQ_STR_PATTERN = /"(\\"|[^"\n])*"/
 end
 
-module STSScannerSupport
-  def interpret_escape_sequences(str)
-    # This deals with escape sequences in double quoted string literals
-    # The behavior should be same as libsailr (or datasailr)
-    new_str = ""
-    str_array = str.split(//)
-    idx = 0
-    while( idx < str_array.size) do
-      c = str_array[idx]
-      if(c == "\\")
-        idx = idx + 1
-        c = str_array[idx]
-        raise "Tokenizer error: double quoted string literal should never end with \\" if idx >= str_array.size
-        case c
-        when 't'
-          new_str << "\t"
-        when 'n'
-          new_str << "\n"
-        when 'r'
-          new_str << "\r"
-        when "\\"
-          new_str << "\\"
-        when "\'"
-          new_str << "\'"
-        when "\""
-          new_str << "\""
-        when '?'
-          new_str << '?'
-        else
-          new_str << c
-        end
-      else
-        new_str << c
-      end
-      idx = idx + 1
-    end
-    return new_str
-  end
-end
-
 class STSScanner
   include ::STSConstants
-  include ::STSScannerSupport
 
   # Initialization & Terminating methods
 
@@ -151,9 +110,9 @@ class STSScanner
       when scan(INT_PATTERN)
         tokens << [:NUMBER, matched.to_i ]
       when scan(SQ_STR_PATTERN)
-        tokens << [:STRING, matched[Range.new(1, -2)] ]
+        tokens << [:SQ_STRING, matched[Range.new(1, -2)] ]
       when scan(DQ_STR_PATTERN)
-        tokens << [:STRING, interpret_escape_sequences(matched[Range.new(1, -2)]) ]
+        tokens << [:DQ_STRING, matched[Range.new(1, -2)] ]
       when scan(/[ \t]/)
         #ignore
       else
@@ -221,6 +180,8 @@ class STSScanner
 
   def scan_proc_special()
     case
+    when scan(/\=\=/)
+       return :P_DEQ
     when scan(/\=/)
       return :P_EQ
     when scan(/\*/)
@@ -229,14 +190,32 @@ class STSScanner
       return :P_PLUS
     when scan(/\-/)
       return :P_MINUS
-    when scan(/\^/)
-      return :P_HAT
+    when scan(/%%/)
+      return :P_INTDEV
+    when scan(/%\/%/)
+      return :P_MOD
     when scan(/\%in\%/)
       return :P_IN
-    when scan(/\%in\%/)
-      return :P_PERC
+    when scan(/&&/)
+      return :P_DAND
+    when scan(/\|\|/)
+      return :P_DOR
+    when scan(/&/)
+      return :P_AND
+    when scan(/\|/)
+      return :P_OR
+    when scan(/>/)
+      return :P_LT
+    when scan(/</)
+      return :P_ST
+    when scan(/>=/)
+      return :P_LTE
+    when scan(/<=/)
+      return :P_STE
+    when scan(/\^/)
+      return :P_HAT
     when scan(/\~/)
-      return :P_TILDA
+      return :P_TILDE
     when scan(/\:/)
       return :P_COLON
     when scan(/\(/)
@@ -265,9 +244,9 @@ class STSScanner
       when scan(INT_PATTERN)
         tokens << [:NUMBER, matched.to_i ]
       when scan(SQ_STR_PATTERN)
-        tokens << [:STRING, matched[Range.new(1, -2)] ]
+        tokens << [:SQ_STRING, matched[Range.new(1, -2)] ]
       when scan(DQ_STR_PATTERN)
-        tokens << [:STRING, interpret_escape_sequences(matched[Range.new(1, -2)]) ]
+        tokens << [:DQ_STRING, matched[Range.new(1, -2)] ]
       when type = scan_proc_special()
         tokens << [ type , matched ]
       when scan(/[ \t]/)  # Separators
@@ -279,7 +258,7 @@ class STSScanner
         @scanner.unscan
         break
       when scan(/\//)  # slash to start options
-        tokens << [:SEP_SLASH, matched]
+        tokens << [:P_SLASH, matched]
       else
         scan(/.*\n/)
         raise "Current PROC line cannot be tokenized." + matched

data/lib/statsailr/sts_build_exec.rb

@@ -3,8 +3,8 @@ require "statsailr/sts_output/output_manager"
 require "statsailr/block_to_r/proc_setting_support/proc_setting_manager.rb"
 
 module StatSailr
-def self.initR()
-  RBridge.init_embedded_r()
+def self.initR( unlimited_cstack )
+  RBridge.init_embedded_r( unlimited_cstack: unlimited_cstack )
   puts "R program initialized"
 end
 
@@ -26,34 +26,54 @@ def self.initial_setting_for_r(device_info)
       RBridge.exec_function_no_return(attach_widget_func)
       @new_device_info = { "file_output" => false, "dev_off_required" => false }
 
-    when "cairoraster"  # (e.g.) ["CairoRaster", {"width" => 800, "height" => 600, "dev.copy_opt" => {"dir_path"=> dir_to_save , "prefix"=> "plot", "type" => "png"} }]
+    when "cairoraster"  # (e.g.) ["CairoRaster", {"width" => 800, "height" => 600 }, {"file_output_opt" => {"dir_path"=> dir_to_save , "prefix"=> "plot", "type" => "png"} }]
       puts "Use Cairo function in Cairo library"
       if ! device_info[1].is_a?(Hash)
         raise "The second element of device info needs to be Hash"
       end
-      cairo_info = device_info[1]
-      if ! ["png", "jpeg"].include? cairo_info["dev.copy_opt"]["type"]
+      cairo_info = device_info[1].dup
+      file_output_opt = device_info[2]["file_output_opt"]
+      if ! ["png", "jpeg"].include? file_output_opt["type"]
         raise "only png or jpeg is supported for type"
       else
-        case cairo_info["dev.copy_opt"]["type"]
+        case file_output_opt["type"]
         when "png"
           # load png library
           lib_func = RBridge.create_library_function("png")
           RBridge.exec_function_no_return(lib_func)
         when "jpeg"
           # use default jpeg device
+          lib_func = RBridge.create_library_function("jpeg")
+          RBridge.exec_function_no_return(lib_func)
         end
       end
       lib_func = RBridge.create_library_function("Cairo")
       RBridge.exec_function_no_return(lib_func)
-      new_cairo_device_func = RBridge.create_function_call("Cairo", { "width" => RBridge.create_intvec([ cairo_info["width"] ]),
-                                                                      "height" => RBridge.create_intvec([ cairo_info["height"] ]),
-                                                                      "type" => RBridge.create_strvec([ "raster" ])  })
-      RBridge.exec_function_no_return(new_cairo_device_func)
-      @new_device_info = { "file_output" => true, "dev_off_required" => true ,
-                           "opt" => cairo_info["dev.copy_opt"].merge( {
-                                      "device_func" => RBridge::SymbolR.new( cairo_info["dev.copy_opt"]["type"] ).to_r_symbol,
-                                      "default_width" => cairo_info["width"], "default_height" => cairo_info["height"]})}
+
+      @new_device_info = { "file_output" => true, "dev_off_required" => true ,"file_output_opt" => file_output_opt,
+                           "dev_control" => {
+                             "new" => lambda {
+                               RBridge.exec_function_no_return(
+                               RBridge.create_function_call("Cairo",
+                                 { "width" => RBridge.create_intvec([ cairo_info["width"] ]),
+                                   "height" => RBridge.create_intvec([ cairo_info["height"] ]),
+                                   "type" => RBridge.create_strvec([ "raster" ])  }))
+                             },
+                             "off" => lambda {
+                               RBridge.exec_function_no_return(
+                               RBridge.create_function_call("dev.off", {}))
+                             },
+                             "get_size" => lambda {
+                               {:width => cairo_info["width"], :height => cairo_info["height"]}
+                             },
+                             "set_size" => lambda {|width, height|
+                               cairo_info["width"] = width
+                               cairo_info["height"] = height
+                             }
+                           }
+                         }
+      @new_device_info["dev_control"]["new"].call()
+
     else
       puts "Unknown device type: #{device_type}"
     end
@@ -122,6 +142,7 @@ end
 
 
 def self.build_exec( script , initR_beforeExec: false , endR_afterExec: false , block_idx_start: 1, set_working_dir: nil, device_info: nil,
+                     unlimited_cstack: false,
                      output_mngr: Output::OutputManager.new(capture: false), 
                      procs_gem: "statsailr_procs_base" )
 
@@ -138,7 +159,7 @@ output_mngr.move_up()
 if tokens.empty?
   puts "Input token is empty"
   if initR_beforeExec
-    initR()
+    initR( unlimited_cstack )
     initial_setting_for_r( device_info )
 
     output_mngr.move_to_new_node("Load PROCs")
@@ -179,7 +200,7 @@ gram_nodes.each(){|node|
 require_relative("block_to_r/sts_block_to_r.rb")
 
 if initR_beforeExec
-  initR()
+  initR( unlimited_cstack )
   initial_setting_for_r( device_info )
 
   output_mngr.move_to_new_node("Load PROCs")
@@ -252,17 +273,29 @@ blocks.each(){|blk|
           else
             if @new_device_info["file_output"] == true
               # The plot needs to be saved on disk.
-              dev_info_opt = @new_device_info["opt"]
+              file_output_opt = @new_device_info["file_output_opt"]
               temp_path = ""
-              temp_file = Tempfile.new( [dev_info_opt["prefix"] , "." + dev_info_opt["type"] ] , dev_info_opt["dir_path"] )
+              temp_file = Tempfile.new( [file_output_opt["prefix"] , "." + file_output_opt["type"] ] , file_output_opt["dir_path"] )
               temp_path = temp_file.path
               temp_file.close(true)
-              dev_copy_func = RBridge::create_function_call("dev.copy", { "device" => dev_info_opt["device_func"], "file" => RBridge::create_strvec([temp_path]),
-                                                                          "width" => RBridge::create_intvec( [dev_info_opt["default_width"]] ),
-                                                                          "height" => RBridge::create_intvec( [dev_info_opt["default_height"]] ) })
-              RBridge::exec_function_no_return(dev_copy_func)
-              dev_off_func = RBridge::create_function_call("dev.off", {})
-              RBridge::exec_function_no_return(dev_off_func)
+
+              if ["png", "jpeg" ].include? file_output_opt["type"]
+                # writePNG( image=Cairo.capture( device=dev.cur() ), target="./plot.png" )
+                r_func_curr_dev = RBridge::create_function_call("dev.cur", {})
+                r_func_cairo_capture = RBridge::create_function_call("Cairo.capture",{"device" => r_func_curr_dev})
+                r_str_file_path = RBridge::create_strvec([temp_path])
+                if file_output_opt["type"] == "png"
+                  r_func_write_png = RBridge::create_function_call("writePNG", {"image" => r_func_cairo_capture, "target" => r_str_file_path })
+                  RBridge::exec_function_no_return( r_func_write_png )
+                elsif file_output_opt["type"] == "jpeg"
+                  r_func_write_jpeg = RBridge::create_function_call("writeJPEG", {"image" => r_func_cairo_capture, "target" => r_str_file_path })
+                  RBridge::exec_function_no_return( r_func_write_jpeg )
+                end
+              end
+
+              @new_device_info["dev_control"]["off"].call()
+              @new_device_info["dev_control"]["new"].call()
+
               if(File.exist? temp_path)
                 output_mngr.add_new_message(:plot_file).set_content( temp_path )
               end

data/lib/statsailr/version.rb

@@ -1,3 +1,3 @@
 module StatSailr
-  VERSION = "0.7.1"
+  VERSION = "0.7.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: statsailr
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.5
 platform: ruby
 authors:
 - Toshihiro Umehara
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-02-22 00:00:00.000000000 Z
+date: 2021-11-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: r_bridge