bets 0.0.13 → 0.0.14

data/lib/rules.rb

@@ -0,0 +1,747 @@
+# encoding: utf-8
+module Rules
+  class Lexical
+    attr_reader :result
+    attr_reader :errors
+    private
+      def initialize
+        # Дерево лексического разбора
+        keywrd_trm = '[\s\;]'
+        digvar_trm = '[\s\)\+\-\*\/\=\>\<\;]'
+        operat_trm = '[\sA-Za-zА-Яа-я0-9\(]'
+
+        @lexems = [
+          [['\.','\s','',:stop],
+           ['','\.',keywrd_trm,'',:dup],
+           ['','','','','','','','','','']],
+          [[';','\s','',:semicolon],
+           ['','','','','','','','']],
+          [['\(','.?\s?','',:l_brace],
+           ['','','','','','','','']],
+          [['\)','.?\s?','',:r_brace],
+           ['','','','','','','','']],
+          [['\=',operat_trm,'',:equ],
+           ['','','','','','','','','','']],
+          [['\+',operat_trm,'',:plus],
+           ['','','','','','','','','','']],
+          [['\-',operat_trm,'',:minus],
+           ['','','','','','','','','','']],
+          [['\*',operat_trm,'',:mul],
+           ['','','','','','','','','','']],
+          [['\/',operat_trm,'',:div],
+           ['','','','','','','','','','']],
+          [['\>',operat_trm,'',:great],
+           [''  ,'=', operat_trm, '', :ge],
+           ['','','','','','','','','','']],
+          [['\<',operat_trm,'',:low],
+           ['','\=',operat_trm,'',:le],
+           ['','\-',keywrd_trm,'',:ret],
+           ['','\>',keywrd_trm,'',:swap],
+           ['','','','','','','','','','']],
+          [['\|', keywrd_trm,'',:lim],
+           ['','','','','','','','','','']],
+
+          [['\-','\-', '[\r\n]','',:comment],
+           ['','', '~', '.', '[\r\n]','',:comment],
+           ['','','','','','','','']],
+
+
+          [['\?','д','а',keywrd_trm,'',:if_yes],
+           ['','н','е','т',keywrd_trm,'',:if_no],
+           ['','|',keywrd_trm,'',:lcp],
+           ['','','','','','','','']],
+
+          [['и',keywrd_trm,'',:and],
+           ['','л','и',keywrd_trm,'',:or],
+           ['','н','а','ч','е',keywrd_trm,'',:else],
+           ['','с','т','и','н','а',keywrd_trm,'',:true],
+           ['','','','','','','','','','']],
+
+          [['л','о','ж','ь',keywrd_trm,'',:false],
+           ['','','','','','','','']],
+
+          [['п','о','д','к','л','ю','ч','и','т','ь',keywrd_trm,'',:include],
+           ['','у','с','т','о',keywrd_trm,'',:nil],           
+           ['','','','','','','','']],
+
+          [['r','u','b','y',keywrd_trm,'',:ruby],
+           ['','','','','','','','']],
+
+          [['\d',digvar_trm,'', :number],
+           [''  ,'\.','~','\d',digvar_trm,'',:float],
+           [''  ,'~','\d',digvar_trm,'',:number],
+           [''  , '',  '','\.','~','\d',digvar_trm,'',:float],
+           ['','','','','','','','','','','','','']],
+
+          [['\"','~','[^"]','\"',keywrd_trm,'',:string],
+           ['','','','','','','','','','']],
+
+          [['\'','~','[^\']','\'',keywrd_trm,'',:string],
+           ['','','','','','','','','','']],
+
+          [['\:','~','[а-яА-Я\w]',keywrd_trm,'',:word],
+           ['','','','','','','','','','']],
+
+          [['[а-яА-Яa-zA-Z]',digvar_trm,'',:var],
+           ['','~','[а-яА-Я\w]',digvar_trm,'',:var],
+           ['','','','\:','\s','',:label],
+           ['','','','','\:','\s','',:proc],
+           ['','','','','','','','','','']],
+
+          [['@','~','[а-яА-Я\w]',digvar_trm,'',:addr],
+           ['','','','','','','','','','']],
+
+          [['!','~','[а-яА-Я\w]',digvar_trm,'',:wvar],
+           ['','','','','','','','','','']],
+
+          [['\x0', '\s', '', :end],
+           ['','','','','','','','','','']],
+          
+          [['.','\s','',:lexical_error],
+           ['', '~', '.','\s', '',:lexical_error],
+           ['','','','','','','','','','']]
+        ]
+        @error_msg = {
+          incorrect_lexem: "Недопустимая лексема"
+        }
+        @result = []
+        @errors = []
+
+        @step = @step_count = 1
+      end
+      # Проход по подлексемам
+      def get_sublexem(lg, tp)
+        bp = p = tp
+        y = x = 0
+        f = false
+        value = ''
+        loop do
+          while @t[p] =~ Regexp.new(lg[y][x]) do 
+            x += 1 unless f
+            value += @t[p]
+            if lg[y][x].empty? 
+              result = {
+                line: @l,
+                begin:  bp,
+                length: p - bp,
+                lexem:  lg[y][x + 1],
+                value: value[0..-2]
+              }
+              return result
+            end
+            p += 1
+            if f == true && not(@t[p] =~ Regexp.new(lg[y][x]))
+              x += 1
+              f = false
+            end
+          end
+ 
+          if lg[y][x] == '~'
+            x += 1
+            f = true
+            next
+          end
+          y += 1
+ 
+          y += 1 while not lg[y][x-1].empty?
+          return nil if lg[y][x].empty?
+        end
+      end
+      # Получить текущую лексему
+      def get_lexem
+        a = 0
+        loop do
+          return nil if @p >= @t.length
+          lg = @lexems[a]
+          while @t[@p] =~ /\s/ do
+            @l += 1 if @t[@p] =~ /\n/
+            @p += 1 
+            return nil if @p >= @t.length
+          end
+          if @t[@p] =~ Regexp.new(lg[0][0])
+            result = get_sublexem(lg, @p)
+            unless result.nil?
+              @p += result[:length]
+              @cls.send(@mth, @p * 20 / @t.length ) unless @cls.nil?
+              return result
+            end
+          end
+          a += 1
+        end
+      end
+    public
+      # Разбор на лексемы
+      def analyze (text, filename)
+        @p = 0
+        @l = 1
+        @t = text + "\n\x0\n" 
+        # Удаление блочных комментариев
+        # @t.gsub!(/\/\*([^*]|[\r\n]|(\*+([^*\/]|[\r\n])))*\*+\//, '')
+        # Удаление строчных комментариев
+        # @t.gsub!(/\-\-.*\n/, '') 
+
+        @result = []
+        @errors = []
+        loop do
+          lexem = get_lexem
+          break if lexem.nil?
+          break if lexem[:lexem] == :end
+          lexem[:filename] = filename
+          if lexem[:lexem] == :lexical_error
+            @errors << {
+              :message => @error_msg[:incorrect_lexem],
+              :lexem   => lexem } if @errors.length < 5
+          else
+            @result << lexem 
+          end
+        end
+      end
+      def set_progress_callback(classp, mth)
+        @cls = classp
+        @mth = mth
+      end
+
+  end
+
+  class Syntax
+    attr_reader :errors
+    private 
+      def initialize
+        # Дерево синтаксического разбора
+        operators = [:plus,:minus,:div,:mul,:great,:ge,:low,:le,:equ,:or,:and]
+        digits = [:number,:float,:true,:false,:nil]
+        strings = [:string,:word]
+        conditions = [:if_yes,:if_no,:else,:lcp,:semicolon]
+        ids = [:var,:proc,:label,:addr,:wvar]
+        term = ids + conditions + operators + digits + strings + [:stop,:l_brace,:end,:ret,:include,:dup,:swap,:lim,:ruby,:comment,nil]
+
+        @syntax = {
+          :stop       => term + [nil],
+          :semicolon  => term + [nil],
+          :dup        => term + [nil],
+          :swap       => term + [nil],
+          :l_brace    => [:l_brace] + digits + [:minus,:var,nil],
+          :r_brace    => [:r_brace] + operators + ids + term + [:semicolon,nil],
+          :equ        => term + [nil],
+          :plus       => term + [nil],
+          :minus      => term + [nil],
+          :mul        => term + [nil],
+          :div        => term + [nil],
+          :great      => term + [nil],
+          :ge         => term + [nil],
+          :low        => term + [nil],
+          :le         => term + [nil],
+          :and        => term + [nil],
+          :or         => term + [nil],
+          :ret        => term + [nil],
+          :if_yes     => term + [nil],
+          :if_no      => term + [nil],
+          :lcp        => term + [nil],
+          :else       => term + [nil],
+          :true       => digits + [:var,:wvar] + operators + conditions + [:r_brace,:end,nil],
+          :false      => digits + [:var,:wvar] + operators + conditions + [:r_brace,:end,nil],
+          :number     => digits + strings + [:var,:wvar] + operators + conditions + [:r_brace,:end,nil], 
+          :float      => digits + strings + [:var,:wvar] + operators + conditions + [:r_brace,:end,nil], 
+          :string     => term + [nil],
+          :var        => operators + term + [nil],
+          :addr       => operators + term + [nil],
+          :wvar       => term + [nil],
+          :label      => term + [nil],
+          :proc       => term + [nil],
+          :include    => term + [nil],
+          :ruby       => term + [nil],
+          :comment    => term + [nil],
+          :nil        => term + [nil],
+          :lim        => term + [nil],
+          :word       => term + [nil],
+          :end        => term + [nil]
+        }
+        
+        @error_msg = {
+          incorrect_syntax: "Недопустимый синтаксис"
+        }
+        @errors = []
+      end
+    public
+      def analyze(lexem_seq)
+        @errors = []
+        sp = nil
+        lp = 0
+        while lp < lexem_seq.length and !lexem_seq[lp + 1].nil? do
+          sp = @syntax[lexem_seq[lp][:lexem]]
+          sp.each do |s|
+            break if s == lexem_seq[lp + 1][:lexem]
+            if s.nil?
+              @errors << {
+                :message => @error_msg[:incorrect_syntax],
+                :lexem => lexem_seq[lp + 1]} if @errors.length < 5
+              break
+            end
+          end 
+          lp += 1
+          @cls.send(@mth, 20 + lp * 20 / lexem_seq.length ) unless @cls.nil?
+        end
+      end
+
+      def set_progress_callback(classp, mth)
+        @cls = classp
+        @mth = mth
+      end
+  end
+
+  class Translator
+    attr_reader :ids
+    attr_reader :debug
+    attr_reader :data_seg
+    attr_reader :code_seg
+    attr_reader :errors
+    attr_reader :includes
+
+    private 
+      def initialize
+        @syntax = Syntax.new
+        @lexical = Lexical.new
+        @uid = 0
+        @errors = 0
+
+        @error_msg = {
+          brace:    "Кол-во открытых скобок не соответствует кол-ву закрытых",
+          include:  "Ошибка открытия файла в инструкции `подключить`"
+        }
+      end
+      def unique_id
+        @uid += 1
+        return "ABC#{@uid}"
+      end
+
+      # Первый проход:
+      def first_pass(lex_seq, libdir)
+        @errors = []
+        @code_seg = []
+        @data_seg = []
+        @ids = {}
+        @debug = []
+        @includes = []
+
+        postfix_stack = []
+        condition_stack = []
+        f_unary = false
+
+        store = nil
+        il = 0
+        while il < lex_seq.length do
+          break if lex_seq[il].nil?
+          case lex_seq[il][:lexem] 
+            # Раздел обработки выражений
+            when :l_brace
+              postfix_stack.push lex_seq[il]
+            when :r_brace
+              loop do 
+                if postfix_stack.last.nil?
+                  @errors << {
+                    message: @error_msg[:brace],
+                    lexem: lex_seq[il]
+                  }
+                  return
+                end
+
+                break if postfix_stack.last[:lexem] == :l_brace
+                d = postfix_stack.pop
+                @code_seg << d[:lexem]
+                @debug << d
+              end
+              postfix_stack.pop
+            when :plus,:minus,:div,:mul,:equ,:great,:low,:ge,:le
+              if postfix_stack.length == 0
+                @code_seg << lex_seq[il][:lexem]
+                @debug << lex_seq[il]
+              else
+                if store[:lexem] == :l_brace and lex_seq[il][:lexem] == :minus
+                  lex_seq[il][:lexem] = :unary_minus 
+                  f_unary = true
+                else
+                  if ([:plus,:minus,:equ,:great,:low,:ge,:le].include? lex_seq[il][:lexem] and !postfix_stack.last.nil? and [:plus,:minus,:div,:mul].include? postfix_stack.last[:lexem]) or (!postfix_stack.last.nil? and [:div,:mul,:unary_minus].include? postfix_stack.last[:lexem])
+                    d = postfix_stack.pop
+                    @code_seg << d[:lexem]
+                    @debug << d
+                  end
+                  postfix_stack.push lex_seq[il]
+                end
+              end
+            # Раздел обработки идентификаторов
+            when :var
+              id = lex_seq[il][:value]
+              if @ids[id].nil?
+                @data_seg << nil
+                @ids[id] = {:type => :var, :addr => @data_seg.length - 1, :changes => [@code_seg.length + 1]}
+              else
+                @ids[id][:changes] << @code_seg.length + 1
+              end
+              if @ids[id][:type] == :var
+                @code_seg << :dpush
+                @debug << lex_seq[il]
+              else
+                @code_seg << 0
+                @debug << lex_seq[il]
+              end
+              @code_seg << @ids[id][:addr]
+              @debug << lex_seq[il]
+            when :wvar
+              id = lex_seq[il][:value][1..-1]
+              if @ids[id].nil?
+                @data_seg << nil
+                @ids[id] = {:type => :var, :addr => @data_seg.length - 1, :changes => [@code_seg.length + 1]}
+              else
+                @ids[id][:changes] << @code_seg.length + 1
+              end
+              @code_seg << :dpop
+              @debug << lex_seq[il]
+              @code_seg << @ids[id][:addr]
+              @debug << lex_seq[il]
+            when :proc
+              id = lex_seq[il][:value].gsub(/\:*/, '')
+              if @ids[id].nil?
+                @ids[id] = {:type => :proc, :addr => @code_seg.length, :changes => []}
+              else
+                @data_seg.delete_at @ids[id][:addr]
+                @ids[id][:addr] = @code_seg.length
+                @ids[id][:type] = :proc
+              end
+            when :label
+              id = lex_seq[il][:value].gsub(/\:*/, '')
+              if @ids[id].nil?
+                @ids[id] = {:type => :label, :addr => @code_seg.length, :changes => []}
+              else
+                @data_seg.delete_at @ids[id][:addr]
+                @ids[id][:addr] = @code_seg.length
+                @ids[id][:type] = :label
+              end
+            # Раздел обработки литералов
+            when :addr
+              @code_seg << :push
+              @debug << lex_seq[il]
+              addr = @ids[lex_seq[il][:value][1..-1]][:addr]
+              @code_seg << addr
+              @debug << lex_seq[il]
+            when :number
+              @code_seg << :push
+              @debug << lex_seq[il]
+              @code_seg << lex_seq[il][:value].to_i * (f_unary ? -1 : 1)
+              @debug << lex_seq[il]
+              f_unary = false
+            when :float
+              @code_seg << :push
+              @debug << lex_seq[il]
+              @code_seg << lex_seq[il][:value].to_f * (f_unary ? -1 : 1)
+              @debug << lex_seq[il]
+              f_unary = false
+            when :string
+              @code_seg << :push
+              @debug << lex_seq[il]
+              @code_seg << lex_seq[il][:value][1..-2]
+              @debug << lex_seq[il]
+            when :word
+              @code_seg << :push
+              @debug << lex_seq[il]
+              @code_seg << lex_seq[il][:value][1..-1]
+              @debug << lex_seq[il]
+            when :uminus
+              f_unary = true
+            # Раздел обработки условий
+            when :true
+              @code_seg << :push
+              @debug << lex_seq[il]
+              @code_seg << 1
+              @debug << lex_seq[il]
+            when :false 
+              @code_seg << :push
+              @debug << lex_seq[il]
+              @code_seg << 0
+              @debug << lex_seq[il]
+            when :nil 
+              @code_seg << :push
+              @debug << lex_seq[il]
+              @code_seg << nil
+              @debug << lex_seq[il]
+            when :if_yes
+              @code_seg << :jne
+              @debug << lex_seq[il]
+              id = unique_id
+              @ids[id] = {:type => :in, :addr => 0, :changes => [@code_seg.length]}
+              @code_seg << 0
+              @debug << lex_seq[il]
+              condition_stack.push id
+            when :if_no
+              @code_seg << :je
+              @debug << lex_seq[il]
+              id = unique_id
+              @ids[id] = {:type => :in, :addr => 0, :changes => [@code_seg.length]}
+              @code_seg << 0
+              @debug << lex_seq[il]
+              condition_stack.push id
+            when :else
+              id_yesno = condition_stack.pop
+              id = unique_id
+              @code_seg << :jmp
+              @debug << lex_seq[il]
+              @ids[id] = {:type => :in, :addr => 0, :changes => [@code_seg.length]}
+              @code_seg << 0
+              @debug << lex_seq[il]
+              condition_stack.push id
+              @ids[id_yesno][:addr] = @code_seg.length
+            when :semicolon
+              id = condition_stack.pop
+              @ids[id][:addr] = @code_seg.length
+            when :include 
+              il += 1
+              # Чтение исходного кода
+              filename = lex_seq[il][:value][1..-2]
+              basename = File.basename(filename)
+              unless File.exist?("#{filename}.rules")
+                filename = File.join(libdir, 'ruleslib', "#{basename}.rules") 
+              end
+              unless File.exist?(filename)
+                gem_file = Gem::find_files("#{basename}_rules.rb").last
+                if gem_file.nil?
+                  @errors << {
+                    message: @error_msg[:include],
+                    lexem: lex_seq[il]
+                  }
+                  return
+                end
+                filename = File.join(File.dirname(gem_file), "#{basename}.rules")
+              end
+              text = ''
+              begin
+                filename = File.expand_path(filename)
+                text = File.open(filename, "r:UTF-8").read
+                @includes << basename
+              rescue Exception => e
+                @errors << {
+                  message: @error_msg[:include],
+                  lexem: lex_seq[il]
+                }
+                return
+              end
+              @lexical.analyze(text, filename)
+              @syntax.analyze(@lexical.result)
+              @errors += @syntax.errors + @lexical.errors
+              @lexical.result.each_index do |i|
+                lex_seq.insert(il+1+i,@lexical.result[i])
+              end
+            when :comment
+            else
+              @code_seg << lex_seq[il][:lexem]
+              @debug << lex_seq[il]
+          end
+          store = lex_seq[il]
+          il += 1
+          @cls.send(@mth, 40 + il * 40 / lex_seq.length ) unless @cls.nil?
+        end
+        while postfix_stack.length > 0 do
+          if postfix_stack.last[:lexem] == :l_brace
+            @errors << {
+              message: @error_msg[:brace],
+              lexem: postfix_stack.last
+            }
+            return
+          end
+          d = postfix_stack.pop
+          @code_seg << d[:lexem]
+          @debug << d
+        end
+        if @errors.length > 0
+          @code_seg = nil
+          @data_seg = nil
+          @debug = nil
+          @ids = nil
+        end
+      end
+      # Второй проход
+      def second_pass
+        i = 0
+        @ids.each do |k,id|
+          id[:changes].each do |c|
+            @code_seg[c] = id[:addr] 
+            @code_seg[c - 1] = :call if id[:type] == :proc
+            @code_seg[c - 1] = :jmp if id[:type] == :label
+          end
+          i += 1
+          @cls.send(@mth, 80 + i * 20 / @ids.length ) unless @cls.nil?
+        end
+      end
+    public
+      def translate(lex_seq, libdir)
+        @ids = {}
+        @debug = []
+        @data_seg = []
+        @code_seg = []
+        first_pass(lex_seq, libdir)
+        # @code_seg.each_index {|i| puts "#{i} -- #{@code_seg[i]}"}
+        second_pass unless @errors.length > 0 
+        # @code_seg.each_index {|i| puts "#{i} -- #{@code_seg[i]}"}
+      end
+
+      def set_progress_callback(classp, mth)
+        @cls = classp
+        @mth = mth
+      end
+  end
+
+  class VM
+      attr_reader :data
+      attr_reader :data_stack
+      attr_reader :limit_stack
+      attr_reader :prog
+      attr_reader :ip
+
+    private
+      def initialize(data_seg, code_seg, debug)
+        @cls = nil
+        @mth = nil
+        # trap("SIGINT") { exit! }
+        # Память данных
+        @data = data_seg
+        # Стек данных
+        @data_stack = []
+        # Стек ограничителей
+        @limit_stack = []
+        # Стек вызовов
+        @call_stack = []
+        # Память программ
+        @prog = code_seg
+        # Указатель текущей инструкции
+        @ip = 0
+        # Отладочная информация
+        @debug = debug
+
+        # Объекты ruby
+        @uid = 0
+        @objects = {}
+      end
+
+    def unique_id
+      @uid += 1
+      return "#vm_#{@uid}"
+    end
+
+    public
+      def halt
+        @thread.terminate unless @thread.nil?
+      end
+
+      def run
+        Thread.abort_on_exception = true
+        @thread = Thread.new do
+          @ip = 0 
+          while @ip < @prog.length do
+            @cls.send(@mth, @debug[@ip]) unless @cls.nil?
+            case @prog[@ip] 
+              when :push
+                @ip += 1; @data_stack.push @prog[@ip]
+              when :call
+                @call_stack.push @ip + 2
+                @ip = @prog[@ip + 1]
+                next
+              when :ret
+                @ip = @call_stack.pop
+                next
+              when :dup
+                @data_stack.push @data_stack.last
+              when :swap
+                a = @data_stack.pop
+                b = @data_stack.pop
+                @data_stack.push a
+                @data_stack.push b
+              when :plus
+                a = @data_stack.pop
+                b = @data_stack.pop
+                @data_stack.push b + a
+              when :minus
+                a = @data_stack.pop
+                b = @data_stack.pop
+                @data_stack.push b - a
+              when :div
+                a = @data_stack.pop
+                b = @data_stack.pop
+                @data_stack.push b / a
+              when :mul
+                a = @data_stack.pop
+                b = @data_stack.pop
+                @data_stack.push b * a
+              when :great
+                a = @data_stack.pop
+                b = @data_stack.pop
+                @data_stack.push b > a
+              when :low
+                a = @data_stack.pop
+                b = @data_stack.pop
+                @data_stack.push b < a
+              when :ge
+                a = @data_stack.pop
+                b = @data_stack.pop
+                @data_stack.push b >= a
+              when :gl
+                a = @data_stack.pop
+                b = @data_stack.pop
+                @data_stack.push b <= a
+              when :equ
+                a = @data_stack.pop
+                b = @data_stack.pop
+                @data_stack.push b == a
+              when :dpush
+                @ip += 1
+                @data_stack.push @data[@prog[@ip]]
+              when :dpop
+                @ip += 1
+                @data[@prog[@ip]] = @data_stack.pop 
+              when :je
+                a = @data_stack.pop
+                a = (a > 0) if a.kind_of? Fixnum or a.kind_of? Float
+                if a 
+                  @ip = @prog[@ip + 1] 
+                else
+                  @ip += 2
+                end
+                next
+              when :jne
+                a = @data_stack.pop
+                a = (a > 0) if a.kind_of? Fixnum or a.kind_of? Float
+                unless a  
+                  @ip = @prog[@ip + 1]
+                else
+                  @ip += 2
+                end
+                next
+              when :jmp
+                @ip = @prog[@ip + 1]
+                next
+              when :stop
+                break
+              when :ruby
+                a = @data_stack.pop
+                begin
+                  send(a)
+                rescue Exception => e
+                  puts e
+                end    
+              when :lim
+                @limit_stack.push @data_stack.length
+              when :lcp
+                a = @data_stack.length
+                b = @limit_stack.pop
+                result = a <= b
+                @limit_stack.push b unless result
+                @data_stack.push result
+            end
+            @ip += 1
+          end
+        end
+      end
+
+      def set_debug_callback(classp, mth)
+        @cls = classp
+        @mth = mth
+      end
+  end
+end