rasel 1.1.3 → 1.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e383f8b5e25f0d283eeeb1eebf5bbe1572206494
-  data.tar.gz: 4b53daac9f618a7be7188ba657703d88d62fbf1e
+  metadata.gz: 8b3b17070c0c2dd2bf982193c8becb0d2f079971
+  data.tar.gz: 053577514bcbe505c5c6bd1766ec0ddf52ae9974
 SHA512:
-  metadata.gz: 5740ece90b2d4f2aafad4031a7f26dfc1d1d68338aaf9bfd8189bed6925e3421dbb47e10ce8aa2cd3e756117f04e0708afaec7e7dd3472fa3b4278e67eb98925
-  data.tar.gz: 8ee6156d49f97c57682d97bab8762f70c69539259cdaf413289949d3b548afbfaad123b43b3a2bef7d6ffccb8fa4c2d2cf3b1533be28296b36e323d71808a88e
+  metadata.gz: bfe946adc630d7fe4c91c9d10f4407c3903dba8255d1c5531681ab387f8117bab5f084a59d9b010873d6e24d1936fe91030488963b43b3520d00367b289cd3f2
+  data.tar.gz: 5c86eb71eecd98797bfefd987400d25c7f91bce3270b3f3ee5588c42f4c80813d5b605e84cf8aa7af5cb5c72abb35792ab2cc278dfdad5a109209a0a1f297eae

data/bin/rasel-annotated

@@ -3,4 +3,4 @@ Signal.trap(:INT){ abort "\n(interrupted by SIGINT)" }
 
 require_relative "../lib/rasel"
 require "json"
-exit RASEL(JSON.load(ARGF.read), STDOUT).exitcode
+exit RASEL::run_annotated(JSON.load(ARGF.read), STDOUT).exitcode

data/bin/rasel-ide

@@ -266,7 +266,7 @@ post "/run" do
   begin
     require "timeout"
     result = Timeout.timeout(2) do
-      RASEL \
+      RASEL::run_annotated \
         JSON.load(File.read ARGV.first),
         StringIO.new,
         StringIO.new.tap{ |_| JSON.load(params.fetch "stdin").bytes.reverse_each &_.method(:ungetbyte) }

data/lib/rasel.rb

@@ -2,6 +2,103 @@ Encoding::default_internal = Encoding::default_external = "ASCII-8BIT"
 END { RubyProf::FlatPrinter.new(RubyProf.stop).print STDERR, min_percent: 1 } if ENV["PROFILE"]
 
 module RASEL
+  ResultStruct = Struct.new :stdout, :stack, :exitcode
+
+  def self.run source, stdout = StringIO.new, stdin = STDIN
+    stack = []
+    pop = ->{ stack.pop || 0 }
+    error = Proc.new{ return RASEL::ResultStruct.new stdout, stack, 255 }
+
+    lines = source.tap{ |_| raise ArgumentError.new "empty source" if _.empty? }.gsub(/ +$/,"").split(?\n)
+    code = lines.map{ |_| _.ljust(lines.map(&:size).max).bytes }
+
+    dx, dy = 1, 0
+    x, y = -1, 0
+
+    # debugging and profiling (currently not maintained)
+    history = {}
+    debug_history = ENV.key? "DEBUG_HISTORY"
+    move = lambda do
+      y = (y + dy) % code.size
+      x = (x + dx) % code[y].size
+      next unless debug_history && (code[y][x] == 32 || code[y][x][0] == 32)
+      history[[x, y]] ||= 0
+      history[[x, y]] += 1
+    end
+    time = Time.now
+    thread = Thread.new do
+      loop do
+        unless Time.now < time + 1
+          time += 1
+          p history.sort_by(&:last).last(10)
+        end
+        sleep 0.1
+      end
+    end if debug_history
+    if ENV["PROFILE"]
+      require "ruby-prof"
+      RubyProf.start
+    end
+
+    reverse = ->{ dy, dx = -dy, -dx }
+    stringmode = false
+    debug = ENV.key? "DEBUG"
+    loop do
+      move[]
+      byte = code[y][x]
+      char = byte.chr
+      STDERR.puts [char, stringmode, (stack.last Integer ENV["DEBUG"] rescue stack)].inspect if debug
+
+      next stack.push byte if stringmode && char != ?"
+      return RASEL::ResultStruct.new stdout, stack, (
+        t = pop[]
+        1 != t.denominator || t < 0 || t > 255 ? 255 : t.to_i
+      ) if char == ?@
+      case char
+        when ?\s
+
+        when ?0..?9 ; stack.push byte - 48
+        when ?A..?Z ; stack.push byte - 55
+        when ?" ; stringmode ^= true
+        when ?# ; move[]
+        when ?$ ; pop[]
+        when ?: ; stack.concat [pop[]] * 2
+        when ?- ; stack.push -(pop[] - pop[])
+        when ?/ ; b, a = pop[], pop[]; stack.push b.zero? ? 0 : Rational(a) / b
+        when ?% ; b, a = pop[], pop[]; stack.push b.zero? ? 0 : Rational(a) % b
+        when ?v ; dx, dy =  0,  1
+        when ?> ; dx, dy =  1,  0
+        when ?^ ; dx, dy =  0, -1
+        when ?< ; dx, dy = -1,  0
+        when ?? ; move[] if pop[] > 0
+        when ?\\
+          t = pop[]
+          error.call if 1 != t.denominator
+          stack.unshift 0 until stack.size > t
+          stack[-t-1], stack[-1] = stack[-1], stack[-t-1] unless 0 > t
+        when ?. ; stdout.print "#{_ = pop[]; 1 != _.denominator ? _.to_f : _.to_i} "
+        when ?, ; stdout.print "#{_ = pop[]; 1 != _.denominator ? error.call : _ < 0 || _ > 255 ? error.call : _.to_i.chr}"
+        when ?~ ; if _ = stdin.getbyte then stack.push _; move[] end
+        when ?&
+          getc = ->{ stdin.getc or throw nil }
+          catch nil do
+            nil until (?0..?9).include? c = getc[]
+            while (?0..?9).include? cc = stdin.getc ; c << cc end
+            stdin.ungetbyte cc if cc
+            stack.push c.to_i
+            move[]
+          end
+        when ?j
+          t = pop[]
+          error.call if 1 != t.denominator
+          y = (y + dy * t.to_i) % code.size
+          x = (x + dx * t.to_i) % code[y].size
+
+        else ; error.call
+      end
+    end
+  end
+
   require "delegate"
   class StackItem < DelegateClass Rational
     attr_reader :annotation
@@ -10,29 +107,13 @@ module RASEL
       @annotation = annotation || (n.annotation if n.respond_to? :annotation)
     end
   end
+  def self.run_annotated source, stdout = StringIO.new, stdin = STDIN
+    stack = []
+    pop = ->{ stack.pop || 0 }
+    error = Proc.new{ return ResultStruct.new stdout, stack, 255 }
 
-  ResultStruct = Struct.new :stdout, :stack, :exitcode
-
-  def self.write_pretty_json where, what
-    File.write where, "[\n  " + (
-      what.map(&JSON.method(:dump)).join ",\n  "
-    ) + "\n]\n"
-  end
-end
-
-def RASEL source, stdout = StringIO.new, stdin = STDIN
-  stack = []
-  pop = ->{ stack.pop || 0 }
-  error = Proc.new{ return RASEL::ResultStruct.new stdout, stack, 255 }
-
-  case source
-  when String
-    lines = source.tap{ |_| raise ArgumentError.new "empty source" if _.empty? }.gsub(/ +$/,"").split(?\n)
-    code = lines.map{ |_| _.ljust(lines.map(&:size).max).bytes }
-  when Array
-    annotate = true
     code = Array.new(source.map{|y,|y}.max+1){ Array.new(source.map{|_,x,|x}.max+1){ " ".ord } }
-    source.each{ |y, x, c, a| code[y][x] = [c.ord, a] }
+    source.each{ |y, x, c, a| code[y][x] = [c.ord, a] unless c.empty? }
     stdout.instance_eval do
       pos = self.pos
       old_puts = method :puts
@@ -40,7 +121,7 @@ def RASEL source, stdout = StringIO.new, stdin = STDIN
       define_singleton_method :puts do |str, reason|
         next if prev == dump = JSON.dump([reason, str])
         old_puts.call prev = dump
-        if 200_000 < stdout.pos - pos
+        if 500_000 < stdout.pos - pos
           old_puts.call JSON.dump [:abort, "printed size"]
           error.call
         end
@@ -49,99 +130,87 @@ def RASEL source, stdout = StringIO.new, stdin = STDIN
         puts str, :print
       end
     end
-  else
-    raise ArgumentError.new "unsupported source class: #{source.class}"
-  end
-  dx, dy = 1, 0
-  x, y = -1, 0
-
-  # debugging and profiling (currently not maintained)
-  history = {}
-  debug_history = ENV.key? "DEBUG_HISTORY"
-  move = lambda do
-    y = (y + dy) % code.size
-    x = (x + dx) % code[y].size
-    next unless debug_history && (code[y][x] == 32 || code[y][x][0] == 32)
-    history[[x, y]] ||= 0
-    history[[x, y]] += 1
-  end
-  time = Time.now
-  thread = Thread.new do
+
+    dx, dy = 1, 0
+    x, y = -1, 0
+
+    move = lambda do
+      y = (y + dy) % code.size
+      x = (x + dx) % code[y].size
+    end
+    time = Time.now
+
+    reverse = ->{ dy, dx = -dy, -dx }
+    stringmode = false
     loop do
-      unless Time.now < time + 1
-        time += 1
-        p history.sort_by(&:last).last(10)
+      if 1 < Time.now - time
+        stdout.puts "timeout", :abort
+        error.call
       end
-      sleep 0.1
-    end
-  end if debug_history
-  if ENV["PROFILE"]
-    require "ruby-prof"
-    RubyProf.start
-  end
+      stdout.puts stack.map{ |_| _.respond_to?(:annotation) && _.annotation ? [_, _.annotation] : _ }, :loop
 
-  reverse = ->{ dy, dx = -dy, -dx }
-  stringmode = false
-  debug = ENV.key? "DEBUG"
-  loop do
-    if annotate && 1 < Time.now - time
-      stdout.puts "timeout", :abort
-      error.call
-    end
-    stdout.puts stack.map{ |_| _.respond_to?(:annotation) && _.annotation ? [_, _.annotation] : _ }, :loop if annotate
-
-    move[]
-    byte, annotation = code[y][x]
-    char = byte.chr
-    STDERR.puts [char, stringmode, (stack.last Integer ENV["DEBUG"] rescue stack)].inspect if debug
-
-    next stack.push byte if stringmode && char != ?"
-    return RASEL::ResultStruct.new stdout, stack, (
-      t = pop[]
-      1 != t.denominator || t < 0 || t > 255 ? 255 : t.to_i
-    ) if char == ?@
-    case char
-      when ?\s
-
-      when ?0..?9 ; stack.push RASEL::StackItem.new byte - 48, annotation
-      when ?A..?Z ; stack.push RASEL::StackItem.new byte - 55, annotation
-      when ?" ; stringmode ^= true
-      when ?# ; move[]
-      when ?$ ; pop[]
-      when ?: ; popped = pop[]; stack.push popped; stack.push RASEL::StackItem.new popped, annotation
-      when ?- ; stack.push RASEL::StackItem.new -(pop[] - pop[]), annotation
-      when ?/ ; b, a = pop[], pop[]; stack.push RASEL::StackItem.new b.zero? ? 0 : Rational(a) / b, annotation
-      when ?% ; b, a = pop[], pop[]; stack.push RASEL::StackItem.new b.zero? ? 0 : Rational(a) % b, annotation
-      when ?v ; dx, dy =  0,  1
-      when ?> ; dx, dy =  1,  0
-      when ?^ ; dx, dy =  0, -1
-      when ?< ; dx, dy = -1,  0
-      when ?? ; move[] if pop[] > 0
-      when ?\\
-        t = pop[]
-        error.call if 1 != t.denominator
-        stack.unshift 0 until stack.size > t
-        stack[-t-1], stack[-1] = RASEL::StackItem.new(stack[-1], annotation), stack[-t-1] unless 0 > t
-      # TODO: annotate prints
-      when ?. ; stdout.print "#{_ = pop[]; 1 != _.denominator ? _.to_f : _.to_i} "
-      when ?, ; stdout.print "#{_ = pop[]; 1 != _.denominator ? error.call : _ < 0 || _ > 255 ? error.call : _.to_i.chr}"
-      when ?~ ; if _ = stdin.getbyte then stack.push RASEL::StackItem.new _, annotation; move[] end
-      when ?&
-        getc = ->{ stdin.getc or throw nil }
-        catch nil do
-          nil until (?0..?9).include? c = getc[]
-          while (?0..?9).include? cc = stdin.getc ; c << cc end
-          stdin.ungetbyte cc if cc
-          stack.push RASEL::StackItem.new c.to_i, annotation
-          move[]
-        end
-      when ?j
+      move[]
+      byte, annotation = code[y][x]
+      char = byte.chr
+
+      next stack.push StackItem.new byte, annotation if stringmode && char != ?"
+      return ResultStruct.new stdout, stack, (
         t = pop[]
-        error.call if 1 != t.denominator
-        y = (y + dy * t.to_i) % code.size
-        x = (x + dx * t.to_i) % code[y].size
+        1 != t.denominator || t < 0 || t > 255 ? 255 : t.to_i
+      ) if char == ?@
+      case char
+        when ?\s
+
+        when ?0..?9 ; stack.push StackItem.new byte - 48, annotation
+        when ?A..?Z ; stack.push StackItem.new byte - 55, annotation
+        when ?" ; stringmode ^= true
+        when ?# ; move[]
+        when ?$ ; pop[]
+        when ?: ; popped = pop[]; stack.push popped; stack.push StackItem.new popped, annotation
+        when ?- ; stack.push StackItem.new -(pop[] - pop[]), annotation
+        when ?/ ; b, a = pop[], pop[]; stack.push StackItem.new b.zero? ? 0 : Rational(a) / b, annotation
+        when ?% ; b, a = pop[], pop[]; stack.push StackItem.new b.zero? ? 0 : Rational(a) % b, annotation
+        when ?v ; dx, dy =  0,  1
+        when ?> ; dx, dy =  1,  0
+        when ?^ ; dx, dy =  0, -1
+        when ?< ; dx, dy = -1,  0
+        when ?? ; move[] if pop[] > 0
+        when ?\\
+          t = pop[]
+          error.call if 1 != t.denominator
+          stack.unshift 0 until stack.size > t
+          stack[-t-1], stack[-1] = StackItem.new(stack[-1], annotation), stack[-t-1] unless 0 > t
+        # TODO: annotate prints
+        when ?. ; stdout.print "#{_ = pop[]; 1 != _.denominator ? _.to_f : _.to_i} "
+        when ?, ; stdout.print "#{_ = pop[]; 1 != _.denominator ? error.call : _ < 0 || _ > 255 ? error.call : _.to_i.chr}"
+        when ?~ ; if _ = stdin.getbyte then stack.push StackItem.new _, annotation; move[] end
+        when ?&
+          getc = ->{ stdin.getc or throw nil }
+          catch nil do
+            nil until (?0..?9).include? c = getc[]
+            while (?0..?9).include? cc = stdin.getc ; c << cc end
+            stdin.ungetbyte cc if cc
+            stack.push StackItem.new c.to_i, annotation
+            move[]
+          end
+        when ?j
+          t = pop[]
+          error.call if 1 != t.denominator
+          y = (y + dy * t.to_i) % code.size
+          x = (x + dx * t.to_i) % code[y].size
 
-      else ; error.call
+        else ; error.call
+      end
     end
   end
+
+  def self.write_pretty_json where, what
+    File.write where, "[\n  " + (
+      what.map(&JSON.method(:dump)).join ",\n  "
+    ) + "\n]\n"
+  end
+end
+
+def RASEL *args
+  RASEL::run *args
 end

data/rasel.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name         = "rasel"
-  spec.version      = "1.1.3"
+  spec.version      = "1.1.4"
   spec.summary      = "Random Access Stack Esoteric Language"
 
   spec.author       = "Victor Maslov aka Nakilon"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rasel
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.1.4
 platform: ruby
 authors:
 - Victor Maslov aka Nakilon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-01 00:00:00.000000000 Z
+date: 2021-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: webrick