voodoo 0.5.0

data/bin/ast.rb

@@ -0,0 +1,47 @@
+module Ast
+  # A program consists of zero or more elements,
+  # each one of which can be a label, an action,
+  # a function definition, or a comment
+  class Program
+    def initialize elements
+      @elements = elements
+    end
+    attr_accessor :elements
+  end
+
+  # A comment contains text
+  class Comment
+    def initialize text
+      @text = text
+    end
+    attr_accessor :text
+  end
+
+  # A label contains text
+  class Label
+    def initialize text
+      @text = text
+    end
+    attr_accessor :text
+  end
+
+  # A function definition has an argument list and contains
+  # a number of actions and/or comments
+  class Function
+    def initialize args, actions
+      @args = args
+      @statements = actions
+    end
+    attr_accessor :args, :actions
+  end
+
+  # An action contains an operation and zero or more
+  # arguments
+  class Action
+    def initialize op, args
+      @op = op
+      @args = args
+    end
+    attr_accessor :op, :args
+  end
+end

data/bin/voodooc

@@ -0,0 +1,146 @@
+#! /usr/bin/env ruby
+
+require 'getoptlong'
+
+require 'voodoo'
+
+usage="USAGE: voodooc [options] <input file>"
+help=<<EOT
+Input file denotes the file to compile. The special name '-' causes
+voodooc to read from standard input. In that case, the -o option is
+mandatory.
+
+Valid options are:
+
+-a <architecture>
+--arch <architecture>
+--architecture <architecture>
+        Select target architecture. Use -a help to get a list of
+        supported architectures.
+
+-f <format>
+--format <format>
+--output-format <format>
+        Select output format. Use -a <architecture> -f help to get a list of
+        supported output formats for architecture.
+
+-o <output file>
+--output <output file>
+--output-file <output file>
+        Set output file name. The special name '-' causes voodooc to write
+        to standard output.
+EOT
+
+input_file = nil
+output_file = nil
+architecture = Voodoo::Config.default_architecture
+output_format = Voodoo::Config.default_format
+
+#
+# Process command line
+#
+
+opts = GetoptLong.new(
+  ['--help', '-h', GetoptLong::NO_ARGUMENT ],
+  ['--arch', '--architecture', '-a', GetoptLong::REQUIRED_ARGUMENT ],
+  ['--output-file', '--output', '-o', GetoptLong::REQUIRED_ARGUMENT ],
+  ['--output-format', '--format', '-f', GetoptLong::REQUIRED_ARGUMENT ]
+)
+
+# Process options
+opts.each do |opt, arg|
+  case opt
+  when '--help'
+    puts usage
+    puts help
+    exit
+  when '--arch'
+    architecture = arg.to_sym
+  when '--output-file'
+    output_file = arg
+  when '--output-format'
+    output_format = arg.to_sym
+  end
+end
+
+if architecture == :help
+  # List supported architectures
+  puts "Supported architectures:"
+  puts Voodoo::CodeGenerator.architectures
+  exit
+end
+
+if output_format == :help
+  # List supported output formats
+  puts "Supported output formats for architecture #{architecture}:"
+  puts Voodoo::CodeGenerator.formats architecture
+  exit
+end
+
+# Get input file name
+if ARGV.length == 1
+  input_file = ARGV[0]
+else
+  if ARGV.length < 1
+    $stderr.puts "no input files"
+  else
+    $stderr.puts "Too many arguments"
+  end
+  $stderr.puts usage
+  exit 0x80
+end
+
+# Select code generator based on output format
+begin
+  generator = Voodoo::CodeGenerator.get_generator :architecture => architecture,
+                                                  :format => output_format
+rescue NotImplementedError
+  if Voodoo::CodeGenerator.architecture_supported? architecture
+    $stderr.puts "Format #{output_format} is not supported for architecture #{architecture}"
+    $stderr.puts "Supported formats for #{architecture} are:"
+    $stderr.puts Voodoo::CodeGenerator.formats(architecture)
+  else
+    $stderr.puts "Architecture #{architecture} is not supported."
+    $stderr.puts "Supported architectures are:"
+    $stderr.puts Voodoo::CodeGenerator.architectures
+  end
+  exit 1
+end
+
+
+#
+# Compile
+#
+
+if input_file == '-'
+  infile = $stdin
+  unless output_file
+    $stderr.puts "The -o option is mandatory when reading from standard input"
+    exit 0x80
+  end
+else
+  infile = open input_file
+  # Set output_file if not already set
+  output_file = generator.output_file_name input_file unless output_file
+end
+
+if output_file == '-'
+  outfile = $stdout
+else
+  outfile = open output_file, 'w'
+end
+
+begin
+  parser = Voodoo::Parser.new infile
+  compiler = Voodoo::Compiler.new parser, generator, outfile
+
+  compiler.compile
+rescue
+  if output_file != '-'
+    File::unlink(output_file) if File::exists?(output_file)
+  end
+  raise
+ensure
+  outfile.close
+  infile.close
+end

data/lib/voodoo.rb

@@ -0,0 +1,74 @@
+require 'voodoo/config'
+require 'voodoo/code_generator'
+require 'voodoo/compiler'
+require 'voodoo/parser'
+
+# = Voodoo - Code Generation for Multiple Target Platforms
+#
+# This module implements a compiler for the {Voodoo programming
+# language}[http://inglorion.net/documents/designs/voodoo/], a simple
+# programming language designed to be a thin abstraction of the CPU's
+# native instruction set.
+#
+# The compiler consists of three parts:
+#
+# 1. The parser (Voodoo::Parser), which reads 
+#    Voodoo[http://inglorion.net/documents/designs/voodoo/] source code and
+#    turns it into Ruby[http://www.ruby-lang.org/] objects.
+#
+# 2. The code generator (a class that implements the methods of
+#    Voodoo::CommonCodeGenerator), which provides methods that generate
+#    code for the target platform.
+#
+# 3. The compiler driver (Voodoo::Compiler), which reads from the parser
+#    and calls the appropriate methods of the code generator.
+#
+# Both the parser and the code generators can be used on their own. For
+# example, you could use the code generator to generate native code for
+# your own programming language without first creating a
+# Voodoo[http://inglorion.net/documents/designs/voodoo/] program.
+#
+# Instead of instantiating a code generator directly, it is recommended
+# that you use Voodoo::CodeGenerator.get_generator to obtain a suitable
+# code generator for your target platform.
+#
+# A few examples to clarify the usage of the module:
+#
+# The following code compiles the source file <tt>test.voo</tt> to an ELF
+# object file called <tt>test.o</tt> containing object code for i386:
+#
+#   require 'voodoo'
+#
+#   File.open('test.voo') do |infile|
+#     parser = Voodoo::Parser.new infile
+#     generator = Voodoo::CodeGenerator.get_generator :architecture => :i386,
+#                                                     :format => :elf
+#     File.open('test.o', 'w') do |outfile|
+#       compiler = Voodoo::Compiler.new parser, generator, outfile
+#       compiler.compile
+#     end
+#   end
+#
+# The following code uses the code generator API to create an object file
+# without the need to create a
+# Voodoo[http://inglorion.net/documents/designs/voodoo/] program:
+#
+#   require 'voodoo'
+#
+#   generator = Voodoo::CodeGenerator.get_generator
+#
+#   generator.add :functions, [:export, :fact], [:label, :fact]
+#   generator.add_function [:n],
+#     [:ifle, [:n, 1],
+#       # then
+#       [[:return, 1]],
+#       # else
+#       [[:let, :x, :sub, :n, 1],
+#        [:set, :x, :call, :fact, :x],
+#        [:return, :mul, :n, :x]]]
+#
+#   File.open('fact.o', 'w') { |outfile| generator.write outfile }
+#
+
+module Voodoo
+end

data/lib/voodoo/code_generator.rb

@@ -0,0 +1,74 @@
+require 'voodoo/config'
+
+module Voodoo
+  # Module for selecting code generators.
+  #
+  # The code generation API is described in Voodoo::CommonCodeGenerator.
+  module CodeGenerator
+    # Hash using target architectures as keys.
+    # Each entry is a hash mapping output format to generator class.
+    @@generators = {}
+
+    module_function
+
+    # Register a code generator.
+    # Example:
+    #   Voodoo::CodeGenerator.register_generator I386NasmGenerator,
+    #                                            :architecture => :i386,
+    #                                            :format => :nasm
+    def register_generator klass, params
+      if params.has_key?(:architecture) && params.has_key?(:format)
+        arch = params[:architecture].to_sym
+        format = params[:format].to_sym
+        format_hash = @@generators[arch] || {}
+        format_hash[format] = klass
+        @@generators[arch] = format_hash
+      else
+        raise ArgumentError, "Need to specify :architecture and :format"
+      end
+    end
+
+    # Get a code generator for the specified parameters
+    def get_generator params = {}
+      params[:architecture] = Config.default_architecture \
+        unless params[:architecture]
+      params[:format] = Config.default_format unless params[:format]
+      arch = params[:architecture].to_sym
+      format = params[:format].to_sym
+      format_hash = @@generators[arch]
+      klass = format_hash ? format_hash[format] : nil
+      if klass
+        return klass.new params
+      else
+        raise NotImplementedError, "No code generator for architecture #{arch} and format #{format}"
+      end
+    end
+
+    # Tests if a given architecture is supported
+    def architecture_supported? arch
+      @@generators.has_key? arch.to_sym
+    end
+
+    # Get an array of supported architectures
+    def architectures
+      @@generators.keys
+    end
+
+    # Tests if a given format is supported for a given architecture
+    def format_supported? arch, format
+      architecture_supported?(arch.to_sym) &&
+        @@generators[arch.to_sym].has_key?(format.to_sym)
+    end
+
+    # Get an array of supported formats for a given architecture
+    def formats architecture
+      @@generators[architecture.to_sym].keys
+    end
+  end
+end
+
+# Load generators
+Dir.glob(File.join(File.dirname(__FILE__), 'generators', '*.rb')).each do |file|
+  name = file.sub(/.*(voodoo\/generators\/.*)\.rb/, "\\1")
+  require name
+end

data/lib/voodoo/compiler.rb

@@ -0,0 +1,45 @@
+module Voodoo
+  # Voodoo compiler driver.
+  # The compiler driver reads input from a parser (see
+  # Voodoo::Parser), feeds it to a code generator (see
+  # Voodoo::CommonCodeGenerator), and writes the generated code.
+  #
+  # An example of its usage can be found on the main page for the
+  # Voodoo module.
+  class Compiler
+    # Initialize a compiler.
+    #
+    # Parameters:
+    # [parser] the parser to be used (see Voodoo::Parser)
+    # [code_generator] the code generator to be used
+    #                  (see Voodoo::CommonCodeGenerator)
+    # [output] an IO object. The generated code will be written to it
+    def initialize parser, code_generator, output
+      @parser = parser
+      @generator = code_generator
+      @output = output
+    end
+
+    # Perform the compilation.
+    def compile
+      section = :code
+      while true
+        statement = @parser.parse_top_level
+
+        break if statement == nil
+        next if statement.empty?
+
+        case statement[0]
+        when :section
+          section = statement[1]
+        when :function
+          @generator.add section, [:function, statement[1]] + statement[2]
+        else
+          @generator.add section, statement
+        end
+      end
+
+      @generator.write @output
+    end
+  end
+end

data/lib/voodoo/config.rb

@@ -0,0 +1,43 @@
+module Voodoo
+  # Methods to get and set configuration parameters
+  module Config
+    # Class that holds configuration parameters
+    class Configuration
+      def initialize
+        @default_architecture = :amd64
+        @default_format = :elf
+        @nasm_command = "/usr/bin/nasm"
+      end
+
+      attr_accessor :default_architecture,
+                    :default_format,
+                    :nasm_command
+    end
+
+    DEFAULT_CONFIGURATION = Configuration.new
+
+    module_function
+
+    def default_architecture
+      DEFAULT_CONFIGURATION.default_architecture
+    end
+
+    def default_architecture= value
+      DEFAULT_CONFIGURATION.default_architecture = value
+    end
+    def default_format
+      DEFAULT_CONFIGURATION.default_format
+    end
+
+    def default_format= value
+      DEFAULT_CONFIGURATION.default_format = value
+    end
+    def nasm_command
+      DEFAULT_CONFIGURATION.nasm_command
+    end
+
+    def nasm_command= value
+      DEFAULT_CONFIGURATION.nasm_command = value
+    end
+  end
+end

data/lib/voodoo/generators/amd64_elf_generator.rb

@@ -0,0 +1,28 @@
+require 'delegate'
+require 'tempfile'
+require 'voodoo/generators/amd64_nasm_generator'
+require 'voodoo/generators/nasm_elf_generator'
+
+module Voodoo
+  # Generator that produces ELF objects for amd64
+  class AMD64ELFGenerator < DelegateClass(AMD64NasmGenerator)
+    def initialize params = {}
+      @nasmgenerator = AMD64NasmGenerator.new params
+      super(@nasmgenerator)
+      @elfgenerator = NasmELFGenerator.new @nasmgenerator, '-f elf64'
+    end
+
+    def output_file_name input_name
+      input_name.sub(/\.voo$/, '') + '.o'
+    end    
+
+    def write io
+      @elfgenerator.write io
+    end
+  end
+
+  # Register class
+  Voodoo::CodeGenerator.register_generator AMD64ELFGenerator,
+                                           :architecture => :amd64,
+                                           :format => :elf
+end