AmberVM 0.0.19

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

@@ -0,0 +1,34 @@
+module AmberVM
+  module Functions
+    class Regmatch < AmberVM::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 AmberVM::Classes[:error].new(1,"INVALID REGULAR EXPRESSION")
+            end
+            if regexp.match(str)
+              AmberVM::Classes::Boolean.new(true)
+            else
+              AmberVM::Classes::Boolean.new(false)
+            end
+          else
+            AmberVM::Classes[:error].new(1,"FUNCTION (#{self.class.to_s}) EXPECTS 2 ARGUMENTS BUT GOT #{params.length}")     
+          end
+        end
+        def signature
+          [AmberVM::Classes::String, AmberVM::Classes::String] # adjust the signature here
+        end
+        
+        def data_type
+          :boolean
+        end
+      end
+      register_for :regmatch
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module AmberVM
+  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
+            AmberVM::Classes[:error].new(1,"#-1 FUNCTION (#{self.class.to_s}) EXPECTS 2 OR 3 ARGUMENTS BUT GOT #{params.length}")
+          end
+        end
+        
+        def signature
+          [AmberVM::Classes::String, AmberVM::Classes::Number, AmberVM::Classes::String]
+        end
+        
+        def data_type
+          :string
+        end
+      end
+      register_for :rjust
+    end
+  end
+end

data/lib/amber/functions/string.rb

@@ -0,0 +1,3 @@
+Dir[File.dirname(__FILE__) + '/string/*.rb'].each do |c|
+  require c
+end

data/lib/amber/functions.rb

@@ -0,0 +1,103 @@
+require 'amber/plugin'
+module AmberVM
+  # This module holds all the functions laded for the rVM to to keep them
+  # organized and handle which are accassabel and which not.
+  module Functions
+    extend AmberVM::PluginHost
+    # Basic Parent for every function defined, it registers it to the
+    # PluginHost and sets up some basic functionality.
+    # Just parent a class to this and define +execute+ as a class function
+    # and it can be handled.
+    class Function
+      
+      # Registers this as plugin and sets up the PluginHost
+      extend AmberVM::Plugin
+      plugin_host Functions
+      
+      class << self
+        # By default every function should have a universal return value,
+        # this make sure it is not refused if it isn't defined correctly.
+        def data_type
+          :any
+        end
+
+        # We want to allow functions to call other functions without going
+        # through explic calls.
+        # Again it isn't exactly encuraged but possible if needed to.        
+        def method_missing(m, *args, &block)
+          # First we check if a function with the name given is defined vor rVM
+          if (AmberVM::Functions::has? m)
+            # if so we call it with the given arguments
+            AmberVM::Functions[m].execute args, @env 
+          else
+            # If not we let ruby do it's magic.
+            super(m, *args, &block)
+          end
+        end
+        
+        #This is for letting he itnerpreter know that it shall interprete the arguments
+        #and not let the function do it itself (this is needed for logical functions)
+        def execargs
+          true
+        end
+        
+        
+        # Call is used to call the function it handles translating the passed
+        # parameters to the correct types or throw a exception if AmberVM::strict
+        # is set.
+        # This is what you want if you call a function to ensure all parameters
+        # are passed correctly.
+        def call params, env, pos = []
+          i = 0
+          pos ||= []
+          # We want to make sure that if we don't have signatures from the
+          # function we have a default signature of any to prevent automatic
+          # type castng in that case
+          sig = :any
+          params = params.map do |p| 
+            # We try to get the next signature if we don't have any further we
+            # take the last one used so [:number, :number, :number] behaves the
+            # same as just [:number] as it will be repeated
+            sig = signature[i] || sig
+            # Now we check if the expected type is not ':any' nor the current 
+            # argument has the right type.
+            if sig != :any and not p.is_a?(sig)
+              # Okay if we have AmberVM::strict set we don't allow auto type
+              # casting so we throw a Exception
+              raise "TYPE MISMATCH! expected #{sig} got #{p.class}(#{pos.join(':')}) at " if AmberVM::strict
+              # Otherwise we try to typecast the parameter.
+              p = sig.new(p)
+            end
+            # Go to the next parameter in the list
+            i+=1
+            # and make sure the former one is replaced (value of the block)
+            p 
+          end if not signature.empty?
+          # Now we execute the function code and cache the esult
+          begin
+            r = execute(params, env)
+          rescue Exception => e
+            raise e
+            raise "#{e} at #{pos.join(':')}"
+          end
+          # print a debug message if needed
+          AmberVM::debug "#{self.inspect}: #{signature.inspect} = '#{r}'" if $DEBUG
+          r
+        end
+        
+        def signature
+          []
+        end
+        
+        
+        # This executes the function code and returns the result.
+        #
+        # It must be implemented for every function used otherwise it will
+        # end up without doing anything.
+        def execute params, env
+          AmberVM::Classes[:error].new(1,"Function code for #{self} not implemented.")
+        end
+      end
+    end
+  end
+end