voodoo 0.7.0 → 1.0.0

data/lib/voodoo/validator.rb

@@ -0,0 +1,391 @@
+module Voodoo
+  # Functionality for validating Voodoo code.
+  module Validator
+
+    # Expressions that take two arguments
+    BINOPS = [:add, :and, :asr, :bsr, :div, :'get-byte', :'get-word',
+              :mod, :mul, :or, :rol, :ror, :shl, :shr, :sub, :xor]
+    # Expressions that take zero or more parameters
+    VARARG_EXPRS = [:call, :'tail-call']
+    # Symbols that may occur as the first word of an expression
+    EXPRS = BINOPS + VARARG_EXPRS + [:not]
+
+    # Symbols that are a valid start of a statement
+    STATEMENTS = [:block, :call, :goto,
+                  :ifeq, :ifge, :ifgt, :ifle, :iflt, :ifne,
+                  :label, :let, :return, :set,
+                  :'set-byte', :'set-word', :'tail-call']
+
+    # Symbols that are valid at top-level
+    TOP_LEVELS = [:align, :byte, :export, :function, :import,
+                  :section, :string, :word] + STATEMENTS
+
+    NTH = ['First', 'Second', 'Third']
+
+    module_function
+
+    # Validates an expression.
+    # Returns true if the expression is valid.
+    # Raises ValidationError if the expression is not valid.
+    def validate_expression code
+      if int_or_symbol_or_at? code
+        true
+      elsif code.respond_to? :[]
+        if BINOPS.member? code[0]
+          # binop should have 2 parameters, both of them atomic values
+          assert_n_params code, 2
+          assert_params_are_values code
+        else
+          # code[0] is not a binop
+          case code[0]
+          when :call, :'tail-call'
+            # call should have at least 1 parameter
+            # and all parameters should be atomic values
+            assert_at_least_n_params code, 1
+            assert_params_are_values code
+          when :'get-byte', :'get-word'
+            # Should have exactly 2 parameters, both of which should be values.
+            assert_n_params code, 2
+            assert_params_are_values code
+          when :not
+            # should have a single, atomic parameter
+            assert_n_params code, 1
+            assert_params_are_values code
+          else
+            raise ValidationError.new("#{code[0].inspect}" +
+                                      " cannot start an expression",
+                                      code)
+          end
+        end
+      else
+        # code is not an atomic value and does not respond to :[]
+        raise ValidationError.new("#{code.inspect} is not a valid expression",
+                                  code)
+      end
+    end
+
+    # Validates a statement.
+    # Returns true if the statement is valid.
+    # Raises ValidationError if the statement is not valid.
+    def validate_statement code
+      begin
+        case code[0]
+        when :block
+          code[1..-1].each {|stmt| validate_statement stmt}
+          true
+
+        when :call, :'tail-call'
+          validate_expression code
+
+        when :goto
+          # should have exactly 1 parameter, which should be atomic
+          assert_n_params code, 1
+          assert_params_are_values code
+
+        when :ifeq, :ifge, :ifgt, :ifle, :iflt, :ifne
+          # Should have 2 or 3 parameters.
+          # First parameter should be an array (or similar) containing
+          # two elements, both atomic.
+          # Second parameter should consist of one or more statements.
+          # Third parameter, if present, should consist of zero or more
+          # statements.
+          # let is not allowed as a statement in either parameter, though
+          # it can be embedded in a block in either.
+          if code.length < 3 || code.length > 4
+            raise ValidationError.new("#{code[0]} takes 2 or 3 parameters",
+                                      code)
+          elsif code[1].length != 2
+            raise ValidationError.new("#{code[0]} requires two values to" +
+                                      " compare in its first parameter",
+                                      code)
+          elsif !code[1].all? {|x| int_or_symbol_or_at? x}
+            raise ValidationError.new("Values to compare should be values" +
+                                      " (symbols, integers, or at-exrpssions)",
+                                      code)
+          else
+            code[2].each do |stmt|
+              validate_statement stmt
+              if stmt[0] == :let
+                raise ValidationError.new("let is not allowed inside " +
+                                          code[0].to_s, code)
+              end
+            end
+
+            if code.length > 3
+              code[3].each do |stmt|
+                validate_statement stmt
+                if stmt[0] == :let
+                  raise ValidationError.new("let is not allowed inside " +
+                                            code[0].to_s, code)
+                end
+              end
+            end
+
+            true
+          end
+
+        when :label
+          # should have 1 parameter which should be a symbol
+          if code.length != 2 || !code[1].kind_of?(::Symbol)
+            raise ValidationError.new("label requires a single symbol" +
+                                      "as its parameter", code)
+          else
+            true
+          end
+
+        when :let, :set
+          # should have at least 2 parameters
+          if code.length < 3
+            raise ValidationError.new("#{code[0]} requires a symbol" +
+                                      " and an expression", code)
+          elsif code[1].kind_of? ::Symbol
+            # After the symbol, there should be an expression
+            expr = code[2..-1]
+            if expr.length == 1
+              validate_expression expr[0]
+            else
+              validate_expression expr
+            end
+          else
+            raise ValidationError.new("First parameter to #{code[0]} should be" +
+                                        " a symbol", code)
+          end
+
+        when :return
+          # Should either have no parameters, or a single expression as
+          # a parameter.
+          case code.length
+          when 1
+            true
+          when 2
+            validate_expression code[1]
+          else
+            validate_expression code[1..-1]
+          end
+
+        when :'set-byte', :'set-word'
+          # Should have exactly 3 parameters, all of which should be
+          # atomic values.
+          assert_n_params code, 3
+          assert_params_are_values code
+
+        else
+          raise ValidationError.new("Not a valid statement: #{code.inspect}",
+                                    code)
+        end
+
+      rescue ValidationError
+        # Pass it on
+        raise
+
+      rescue Exception => e
+        if code.respond_to? :[]
+          # Pass on the exception
+          raise
+        else
+          raise ValidationError.new("#{code.inspect} does not respond to" +
+                                    ":[]", code)
+        end
+
+      end
+    end
+
+    # Validates a top-level directive.
+    # Returns true if the directive is valid.
+    # Raises ValidationError if the directive is not valid.
+    def validate_top_level code
+      begin
+        case code[0]
+        when :align
+          # Should either have no parameter or a single integer parameter
+          if code.length == 1 || (code.length == 2 &&
+                                  code[1].kind_of?(::Integer))
+            true
+          else
+            raise ValidationError.new("align requires either a single" +
+                                      " integer parameter, or no parameters",
+                                      code)
+          end
+
+        when :byte, :word
+          # Should have a single integer or symbol parameter
+          if code.length != 2 || !int_or_symbol?(code[1])
+            raise ValidationError.new("#{code[0]} requires a single" +
+                                      " parameter that is either an " +
+                                      " integer or a symbol", code)
+          else
+            true
+          end
+
+        when :export, :import
+          # Should have at least 1 parameter, and all parameters should
+          # be symbols.
+          if code.length < 2
+            raise ValidationError.new("#{code[0]} requires at least " +
+                                      " one parameter", code)
+          elsif code[1..-1].all? {|x| x.kind_of? ::Symbol}
+            true
+          else
+            raise ValidationError.new("All parameters to #{code[0]}" +
+                                      " should be symbols", code)
+          end
+
+        when :function
+
+          # Check that formal parameters have been specified
+          if code.length < 2
+            raise ValidationError.new("Formal parameters should be" +
+                                      " specified for function",
+                                      code)
+          end
+
+          # Check that all formal parameters are symbols
+          code[1].each do |formal|
+            unless formal.kind_of? ::Symbol
+              raise ValidationError.new("Formal parameter #{formal.inspect}" +
+                                        " should be a symbol",
+                                        formal)
+            end
+          end
+
+          # Verify statements
+          code[2..-1].each do |stmt|
+            if stmt.respond_to?(:[]) && stmt[0] == :function
+              raise ValidationError.new("Function definitions are only " +
+                                        "valid at top-level", stmt)
+            else
+              validate_statement stmt
+            end
+          end
+
+        when :section
+
+          # Check that we have a string or a symbol
+          case code.length
+          when 1
+            raise ValidationError.new("Section name should be specified",
+                                      code)
+          when 2
+            unless code[1].kind_of?(::String) || code[1].kind_of?(::Symbol)
+              raise ValidationError.new("Section name should be a string" +
+                                        " or a symbol",
+                                        code)
+            end
+
+          else
+            raise ValidationError.new("section directive should have only" +
+                                      " a single parameter",
+                                      code);
+          end
+
+        when :string
+          # Should have a single string parameter
+          if code.length != 2 || !code[1].kind_of?(::String)
+            raise ValidationError.new("string requires a single string" +
+                                      " as a parameter", code)
+          else
+            true
+          end
+
+        else
+          if STATEMENTS.member? code[0]
+            validate_statement code
+          else
+            raise ValidationError.new("Directive #{code[0]}" +
+                                      " not valid at top-level",
+                                      code)
+          end
+        end
+
+      rescue ValidationError
+        # Pass it on
+        raise
+
+      rescue Exception => e
+        if code.respond_to? :[]
+          # Pass on the exception
+          raise
+        else
+          raise ValidationError.new("#{code.inspect} does not respond to" +
+                                    ":[]", code)
+        end
+      end
+
+      # If we got here, all is well
+      true
+    end
+
+    # Base class for errors signaled by the Validator.
+    class ValidationError < StandardError
+      def initialize message, code = nil
+        super message
+        @code = code
+      end
+      attr_reader :code
+    end    
+
+    # Tests that an expression has at least n parameters. Raises a
+    # ValidationError if this is not the case.
+    def assert_at_least_n_params expr, n
+      if expr.length <= n
+        if n == 1
+          raise ValidationError.new \
+            "#{expr[0]} should have at least one parameter"
+        else
+          raise ValidationError.new \
+            "#{expr[0]} should have at least #{n} parameters"
+        end
+      end
+      true
+    end
+
+    # Tests that an expression has exactly n parameters. Raises a
+    # ValidationError if this is not the case.
+    def assert_n_params expr, n
+      if expr.length != n + 1
+        if n == 1
+          raise ValidationError.new \
+            "#{expr[0]} should have exactly one parameter"
+        else
+          raise ValidationError.new \
+            "#{expr[0]} should have exactly #{n} parameters"
+        end
+      end
+      true
+    end
+
+    # Tests that parameters to an expression are
+    # values (integers, symbols, or at-expressions),
+    # and raises ValidationError if this is not the
+    # case.
+    # If ns is nil (default) all parameters should me
+    # values.
+    # Alternatively, ns may be a range or array containing
+    # the indices of the parameters that should be
+    # values.
+    def assert_params_are_values expr, ns = nil
+      if ns == nil
+        ns = (1...expr.length)
+      end
+      ns.each do |i|
+        unless int_or_symbol_or_at?(expr[i])
+          raise ValidationError.new \
+            "#{NTH[i - 1]} parameter to #{expr[0]}" +
+            " should be a value (symbol, integer, or at-expression)"
+        end
+      end
+      true
+    end
+
+    def int_or_symbol? x
+      x.kind_of?(::Symbol) || x.kind_of?(::Integer)
+    end
+
+    def int_or_symbol_or_at? x
+      int_or_symbol?(x) ||
+        (x.respond_to?(:length) && x.length == 2 && x[0] == :'@' &&
+         int_or_symbol?(x[1]))
+    end
+
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: voodoo
 version: !ruby/object:Gem::Version 
-  hash: 3
+  hash: 23
   prerelease: false
   segments: 
+  - 1
   - 0
-  - 7
   - 0
-  version: 0.7.0
+  version: 1.0.0
 platform: ruby
 authors: 
 - Robbert Haarman
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-15 00:00:00 +01:00
+date: 2012-01-14 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -41,18 +41,20 @@ files:
 - lib/voodoo/code_generator.rb
 - lib/voodoo/compiler.rb
 - lib/voodoo/config.rb
-- lib/voodoo/generators/amd64_elf_generator.rb
+- lib/voodoo/validator.rb
 - lib/voodoo/generators/common_code_generator.rb
-- lib/voodoo/generators/nasm_generator.rb
+- lib/voodoo/generators/mips_gas_generator.rb
+- lib/voodoo/generators/i386_elf_generator.rb
+- lib/voodoo/generators/command_postprocessor.rb
 - lib/voodoo/generators/mips_elf_generator.rb
 - lib/voodoo/generators/gas_elf_generator.rb
+- lib/voodoo/generators/arm_elf_generator.rb
+- lib/voodoo/generators/arm_gas_generator.rb
 - lib/voodoo/generators/amd64_nasm_generator.rb
-- lib/voodoo/generators/mips_gas_generator.rb
-- lib/voodoo/generators/generator_api1.rb
-- lib/voodoo/generators/i386_nasm_generator.rb
-- lib/voodoo/generators/command_postprocessor.rb
 - lib/voodoo/generators/nasm_elf_generator.rb
-- lib/voodoo/generators/i386_elf_generator.rb
+- lib/voodoo/generators/amd64_elf_generator.rb
+- lib/voodoo/generators/nasm_generator.rb
+- lib/voodoo/generators/i386_nasm_generator.rb
 has_rdoc: true
 homepage: http://inglorion.net/software/voodoo/
 licenses: []

data/lib/voodoo/generators/generator_api1.rb

@@ -1,95 +0,0 @@
-module Voodoo
-  # This module implements the old code generation API, consisting of
-  # the following methods:
-  #
-  # #add_code
-  # #add_code_label
-  # #add_data
-  # #add_data_label
-  # #add_function
-  # #add_function_label
-  # #align_code
-  # #align_data
-  # #align_function
-  #
-  module GeneratorApi1
-    # Add code.
-    #
-    # Parameters:
-    # [actions] an Array of actions to be added
-    #
-    # Example:
-    #   add_code [:call, :exit, 0]
-    def add_code *actions
-      add :code, *actions
-    end
-
-    # Add a label at the current address in the code section.
-    #
-    # Example:
-    #   add_code_label :mylabel
-    def add_code_label name
-      in_section(:code) { label name }
-    end
-
-    # Add data.
-    #
-    # Parameters:
-    # [defs] an Array of data definitions
-    #
-    # Example:
-    #   add_data [:word, 42]
-    def add_data *defs
-      add :data, *defs
-    end
-
-    # Add a label at the current address in the data section.
-    #
-    # Example:
-    #   add_data_label :msg
-    def add_data_label name
-      add :data, [:label, name]
-    end
-
-    # Add a label at the address where the next function will be generated.
-    #
-    # Example:
-    #   add_function_label :add_one
-    def add_function_label name
-      add :functions, [:label, name]
-    end
-
-    # Align code on the next _alignment_-byte boundary.
-    # If _alignment_ is not specified, the default code alignment
-    # is used.
-    def align_code alignment = nil
-      if alignment
-        add :code, [:align, alignment]
-      else
-        add :code, [:align]
-      end
-    end
-
-    # Align data on the next _alignment_-byte boundary.
-    # If _alignment_ is not specified, the default data alignment
-    # is used.
-    def align_data alignment = nil
-      if alignment
-        add :data, [:align, alignment]
-      else
-        add :data, [:align]
-      end
-    end
-
-    # Align function on the next _alignment_-byte boundary.
-    # If _alignment_ is not specified, the default function alignment
-    # is used.
-    def align_function alignment = nil
-      if alignment
-        add :functions, [:align, alignment]
-      else
-        add :functions, [:align]
-      end
-    end
-  end
-end