rVM 0.0.1

data/lib/rvm/functions/list/split.rb

@@ -0,0 +1,24 @@
+module RVM
+  module Functions
+    class Split < Function
+      class << self
+        def execute params, env
+          if params.length == 2
+            RVM::Classes[:list].new(params[0].to_s,params[1])
+          else
+            RVM::Classes[:error].new(1,"#-1 FUNCTION (#{self.class.to_s}) EXPECTS 2 OR 3 ARGUMENTS BUT GOT #{params.length}")
+          end
+        end
+        
+        def signature
+          [:string, :string]
+        end
+        
+        def data_type
+          :list
+        end
+      end
+      register_for :split
+    end
+  end
+end

data/lib/rvm/functions/logic/and.rb

@@ -0,0 +1,25 @@
+module RVM
+  module Functions
+    class And < RVM::Functions::Function
+      @@type=:any
+      class << self
+        def execute params, env
+          result = true
+          while result and not params.empty?
+            result = result && params.shift.execute(env).is_true?
+          end
+          result
+        end
+        
+        def signature
+          [:any] # adjust the signature here
+        end
+        
+        def execargs
+          false
+        end
+      end
+      register_for :and
+    end
+  end
+end

data/lib/rvm/functions/math/add.rb

@@ -0,0 +1,18 @@
+module RVM
+	module Functions
+		class Add < Function
+			def Add.execute params, env
+				a = RVM::Classes[:number].new 0
+				params.each do |p|
+					a += p
+				end
+				a
+			end
+
+			def Add.signature
+				[:number, :number]
+			end
+			register_for :add
+		end
+	end
+end

data/lib/rvm/functions/math/div.rb

@@ -0,0 +1,21 @@
+module RVM
+	module Functions
+		class Div < Function
+			def Div.execute params, env
+				a = RVM::Classes[:number].new params.shift
+				params.each do |p|
+					if p == 0
+						return RVM::Classes[:error].new(1,"DIVISION BY ZERO")
+					end
+					a /= p
+				end
+				a
+			end
+
+			def Div.signature
+				[:number, :number]
+			end
+			register_for :div
+		end
+	end
+end

data/lib/rvm/functions/math/mul.rb

@@ -0,0 +1,18 @@
+module RVM
+	module Functions
+		class Mul < Function
+			def Mul.execute params, env
+				a = RVM::Classes[:number].new params.shift
+				params.each do |p|
+					a *= p
+				end
+				a
+			end
+
+			def Mul.signature
+				[:number, :number]
+			end
+			register_for :mul
+		end
+	end
+end

data/lib/rvm/functions/math/neg.rb

@@ -0,0 +1,18 @@
+module RVM
+	module Functions
+		class Neg < Function
+			def Neg.execute params, env
+				if params.length == 1
+					RVM::Classes[:number].new(params[0] * -1)
+				else
+					RVM::Classes[:error].new(1,"FUNCTION (#{self.name}) EXPECTS 1 ARGUMENTS BUT GOT #{params.length}")
+				end
+			end
+
+			def Neg.signature
+				[:number]
+			end
+			register_for :neg
+		end
+	end
+end

data/lib/rvm/functions/math/power.rb

@@ -0,0 +1,18 @@
+module RVM
+	module Functions
+		class Power < Function
+			def Power.execute params, env
+				if params.length == 2
+					RVM::Classes[:number].new(params[0] ** params[1])
+				else
+					RVM::Classes[:error].new(1,"FUNCTION (#{self.name}) EXPECTS 2 ARGUMENTS BUT GOT #{params.length}")
+				end
+			end
+
+			def Power.signature
+				[:number, :number]
+			end
+			register_for :power
+		end
+	end
+end

data/lib/rvm/functions/math/sub.rb

@@ -0,0 +1,18 @@
+module RVM
+	module Functions
+		class Sub < Function
+			def Sub.execute params, env
+				a = RVM::Classes[:number].new params.shift
+				params.each do |p|
+					a -= p
+				end
+				a
+			end
+
+			def Sub.signature
+				[:number, :number]
+			end
+			register_for :sub
+		end
+	end
+end

data/lib/rvm/functions/string/ansi.rb

@@ -0,0 +1,24 @@
+module RVM
+  module Functions
+    class Ansi < Function
+      class << self
+        def execute params, env
+          if params.length == 2
+            params[1].ansi params[0]
+          else
+            RVM::Classes[:error].new(1,"FUNCTION (#{self.class.to_s}) EXPECTS 2 ARGUMENTS BUT GOT #{params.length}")
+          end
+        end
+        
+        def signature
+          [:string,  :string]
+        end
+        
+        def data_type
+          :string
+        end
+      end
+      register_for :ansi
+    end
+  end
+end

data/lib/rvm/functions/string/capstr.rb

@@ -0,0 +1,23 @@
+module RVM
+  module Functions
+    class Capstr < RVM::Functions::Function
+      class << self
+        def execute params, env
+          if (params.length == 1)
+            RVM::Classes[:string].new(params.first.capitalize)
+          else
+            RVM::Classes[:error].new(1,"#-1 FUNCTION (#{self.class.to_s}) EXPECTS 1 ARGUMENT BUT GOT #{params.length}")            
+          end
+        end
+        
+        def signature
+          [:string]
+        end
+        def data_type
+          :string
+        end
+      end
+      register_for :capstr
+    end
+  end
+end

data/lib/rvm/functions/string/center.rb

@@ -0,0 +1,25 @@
+module RVM
+  module Functions
+    class Center < Function
+      class << self
+        def execute params, env
+          if params.length == 2
+            params[0].center(params[1])
+          elsif params.length == 3
+            params[0].center(params[1], params[2])
+          else
+            RVM::Classes[:error].new(1,"#-1 FUNCTION (#{self.class.to_s}) EXPECTS 2 OR 3 ARGUMENTS BUT GOT #{params.length}")
+          end
+        end
+        
+        def signature
+          [:string, :number, :string]
+        end
+        def data_type
+          :string
+        end
+      end
+      register_for :center
+    end
+  end
+end

data/lib/rvm/functions/string/ljust.rb

@@ -0,0 +1,26 @@
+module RVM
+  module Functions
+    class Ljust < Function
+      class << self  
+        def execute params, env
+          if params.length == 2
+            params[0].ljust params[1]
+          elsif params.length == 3
+            params[0].ljust params[1], params[2]
+          else
+            RVM::Classes[:error].new(1,"#-1 FUNCTION (#{self.class.to_s}) EXPECTS 2 OR 3 ARGUMENTS BUT GOT #{params.length}")
+          end
+        end
+        
+        def signature
+          [:string, :number, :string]
+        end
+        
+        def data_type
+          :string
+        end
+      end
+      register_for :ljust
+    end
+  end
+end

data/lib/rvm/functions/string/regmatch.rb

@@ -0,0 +1,34 @@
+module RVM
+  module Functions
+    class Regmatch < RVM::Functions::Function
+      class << self
+        def execute params, env
+          if params.length == 2
+            str = params[0]
+            regexp = params[1].to_s
+            begin
+              regexp = Regexp.new(regexp)
+            rescue
+              return RVM::Classes[:error].new(1,"INVALID REGULAR EXPRESSION")
+            end
+            if regexp.match(str)
+              RVM::Classes[:boolean].new(true)
+            else
+              RVM::Classes[:boolean].new(false)
+            end
+          else
+            RVM::Classes[:error].new(1,"FUNCTION (#{self.class.to_s}) EXPECTS 2 ARGUMENTS BUT GOT #{params.length}")     
+          end
+        end
+        def signature
+          [:string, :string] # adjust the signature here
+        end
+        
+        def data_type
+          :boolean
+        end
+      end
+      register_for :regmatch
+    end
+  end
+end

data/lib/rvm/functions/string/rjust.rb

@@ -0,0 +1,25 @@
+module RVM
+  module Functions
+    class Rjust < Function
+      class << self  
+        def execute params, env
+          if params.length == 2
+            params[0].rjust params[1]
+          elsif params.length == 3
+            params[0].rjust params[1], params[2]
+          else
+            RVM::Classes[:error].new(1,"#-1 FUNCTION (#{self.class.to_s}) EXPECTS 2 OR 3 ARGUMENTS BUT GOT #{params.length}")
+          end
+        end
+        
+        def signature
+          [:string, :number, :string]
+        end
+        def data_type
+          :string
+        end
+      end
+      register_for :rjust
+    end
+  end
+end

data/lib/rvm/languages/math/compiler.rb

@@ -0,0 +1,36 @@
+module RVM
+	module Languages
+		module Math
+			class Compiler
+				include RVM::Interpreter
+				FUNCTION_MAP = {
+					'+' => :add,
+					'-' => :sub,
+					'/' => :div,
+					'*' => :mul,
+					'^' => :power
+					}
+				def Compiler.compile tree
+					if tree.is_a? Array
+						compile tree.first
+					elsif tree.is_a? Hash
+						case tree[:type]
+						when :number
+							Interpreter.const(:number, tree[:number])
+						when :function
+							params = tree[:params].map {|p| compile p}
+							case tree[:op]
+							when '-'
+								FunctionCall.new :neg, params
+							else
+								FunctionCall.new tree[:op], params
+							end
+						when :op
+							FunctionCall.new(FUNCTION_MAP[tree[:op]], [compile(tree[:left]),compile(tree[:right])])
+						end
+					end
+				end
+			end
+		end
+	end
+end

data/lib/rvm/languages/math/tokenizer.rb

@@ -0,0 +1,47 @@
+require 'strscan'
+module RVM
+	module Languages
+		module Math
+			class Tokenizer
+				def Tokenizer.tokenize str
+					s = StringScanner.new str
+					tokens = []
+					state = :number
+					while not s.eos?
+						s.skip(/\s*/)
+						if state == :number
+							if s.scan(/[+-]+/)
+								t = s.matched.gsub('+','').gsub('--','')
+								if t == '-'
+									tokens << [t, :function]
+								end
+							elsif s.scan(/[a-z][a-z0-9]*/i)
+								tokens << [s.matched, :function]
+							elsif s.scan(/[\d]+(\.\d+)?/i)
+								tokens << [s.matched, :number]
+								state = :opperator
+							elsif s.scan(/\(/)
+								tokens << [s.matched, :paren_open]
+							else
+								return []
+							end
+						else
+							if s.scan(/\)/)
+								tokens << [s.matched, :paren_close]
+							elsif s.scan(/,/)
+								tokens << [s.matched, :function_sep]
+								state = :number
+							elsif s.scan(/[*+\/^-]/)
+								tokens << [s.matched, :opperator]
+								state = :number
+							else
+								return []
+							end
+						end
+					end
+					tokens
+				end
+			end
+		end
+	end
+end

data/lib/rvm/languages/math/tree.rb

@@ -0,0 +1,100 @@
+module RVM
+	module Languages
+		module Math
+				class Tree
+				PRIORITIES = {
+					'(' => 0,
+					'+' => 1,
+					'-' => 1,
+					'*' => 2,
+					'/' => 2,
+					'^' => 3,
+					}
+				ASSOSICATIONS = {
+					'+' => :left,
+					'-' => :left,
+					'*' => :left,
+					'/' => :left,
+					'^' => :right
+					}
+				def Tree.generate tokens
+					output = []
+					dbgoutput = []
+						stack = []
+					dbgstack = []
+					while not tokens.empty?
+						token = tokens.shift
+						case token[1]
+						when :function 
+							fun = token[0]
+							stack << {:type => :function, :op => fun}
+							output << {:type => :function_end}
+							dbgoutput << ')'
+							dbgstack << fun
+						when :function_sep
+							while stack.last && (stack.last[:op] != '(')
+								output << stack.pop
+								dbgoutput << dbgstack.pop
+							end
+						when :paren_open
+							op = token[0]
+							stack << {:type => :op, :op => op}
+							dbgstack << op
+						when :paren_close
+							while stack.last && (stack.last[:op] != '(')
+								output << stack.pop
+								dbgoutput << dbgstack.pop
+							end
+							stack.pop
+							dbgstack.pop
+							if stack.last && (stack.last[:type] == :function)
+								output << stack.pop
+								dbgoutput << dbgstack.pop
+							end
+						when :number
+							output << {:type => :number, :number => token[0]}
+							dbgoutput << token[0]
+						when :opperator
+							op = token[0]
+							ass = ASSOSICATIONS[op]
+							o1p = PRIORITIES[op]
+							while stack.last && 
+								(((ass == :left) && (o1p <= PRIORITIES[stack.last[:op]])) || 
+								((ass == :right) && (o1p < PRIORITIES[stack.last[:op]])))
+								output << stack.pop
+								dbgoutput << dbgstack.pop
+							end
+							stack << {:type => :op, :op => op}
+							dbgstack << op
+						else
+						end
+					end
+					while not stack.empty?
+						output <<  stack.pop
+					end
+					gen_tree output
+				end
+	
+				private
+				def Tree.gen_tree data
+					item = data.pop
+					case item[:type]
+					when :number
+						item
+					when :op
+						item[:right] = gen_tree(data)
+						item[:left] = gen_tree(data)
+						item
+					when :function
+						item[:params] = []
+						while data.last && data.last[:type] != :function_end
+							item[:params] << gen_tree(data)
+						end
+						data.pop
+						item
+					end
+				end
+			end
+		end
+	end
+end

data/lib/rvm/languages/math.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/math/tokenizer'
+require File.dirname(__FILE__) + '/math/tree'
+require File.dirname(__FILE__) + '/math/compiler'
+module RVM
+	module Languages
+		class MathLanguage < Language
+			include Math
+			def compile text
+			  Compiler.compile(Tree.generate(Tokenizer.tokenize(text)))
+			end
+			register_for :math
+		end
+	end
+end

data/lib/rvm.rb

@@ -0,0 +1,33 @@
+require 'rvm/base/interpreter'
+require 'rvm/base/classes'
+require 'rvm/base/functions'
+require 'rvm/base/languages'
+#This is the rVM Library
+module RVM
+  class << self
+  @@strict = false
+
+  def strict
+  end
+
+  def compile language, code
+    compiler_for(language).compile(code)
+  end
+
+  def compiler_for language
+   if l = RVM::Languages[language]
+      l
+    else
+      raise "RVM Error: Unknown Language #{language}"
+    end
+  end
+
+  def strict= v
+    @@strict = v
+  end
+
+  def debug text
+    puts text if $DEBUG
+  end
+  end
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification 
+name: rVM
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Heinz N. Gies
+autorequire: ""
+bindir: bin
+cert_chain: []
+
+date: 2008-02-28 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: 
+email: heinz@licenser.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- lib/rvm
+- lib/rvm/base
+- lib/rvm/base/classes.rb
+- lib/rvm/base/functions.rb
+- lib/rvm/base/interpreter.rb
+- lib/rvm/base/languages.rb
+- lib/rvm/base/plugin.rb
+- lib/rvm/classes
+- lib/rvm/classes/block.rb
+- lib/rvm/classes/boolean.rb
+- lib/rvm/classes/error.rb
+- lib/rvm/classes/list.rb
+- lib/rvm/classes/number.rb
+- lib/rvm/classes/string.rb
+- lib/rvm/functions
+- lib/rvm/functions/list
+- lib/rvm/functions/list/align.rb
+- lib/rvm/functions/list/join.rb
+- lib/rvm/functions/list/map.rb
+- lib/rvm/functions/list/split.rb
+- lib/rvm/functions/logic
+- lib/rvm/functions/logic/and.rb
+- lib/rvm/functions/math
+- lib/rvm/functions/math/add.rb
+- lib/rvm/functions/math/div.rb
+- lib/rvm/functions/math/mul.rb
+- lib/rvm/functions/math/neg.rb
+- lib/rvm/functions/math/power.rb
+- lib/rvm/functions/math/sub.rb
+- lib/rvm/functions/string
+- lib/rvm/functions/string/ansi.rb
+- lib/rvm/functions/string/capstr.rb
+- lib/rvm/functions/string/center.rb
+- lib/rvm/functions/string/ljust.rb
+- lib/rvm/functions/string/regmatch.rb
+- lib/rvm/functions/string/rjust.rb
+- lib/rvm/languages
+- lib/rvm/languages/math
+- lib/rvm/languages/math/compiler.rb
+- lib/rvm/languages/math/tokenizer.rb
+- lib/rvm/languages/math/tree.rb
+- lib/rvm/languages/math.rb
+- lib/rvm.rb
+- README
+has_rdoc: true
+homepage: http://code.licenser.net/projects/show/rvm
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: rmush
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: A ruby based VM that lets one add secure scripting to ruby applications.
+test_files: []
+