rubex 0.1.1 → 0.1.2

data/lib/rubex/cli.rb

@@ -2,25 +2,30 @@ require 'thor'
 module Rubex
   # Cli for rubex using Thor(http://whatisthor.com/)
   class Cli < Thor
-    desc 'generate FILE', 'generates directory with name specified in the argument and creates an extconf.rb file which is required for C extensions'
+    
+    desc 'generate FILE',
+         'generates directory with name specified in the argument and creates an extconf.rb file which is required for C extensions'
     option :force, aliases: '-f', desc: 'replace existing files and directories'
     option :dir, aliases: '-d', desc: 'specify a directory for generating files', type: :string
-    option :install, aliases: '-i', desc: 'automatically run install command after generating Makefile'
+    option :install, aliases: '-i',
+           desc: 'automatically run install command after generating Makefile'
     option :debug, aliases: '-g', desc: 'enable debugging symbols when compiling with GCC'
     def generate(file)
       if (force = options[:force])
-        directory = (options[:dir] ? options[:dir].to_s : Dir.pwd) + "/#{Rubex::Compiler.extract_target_name(file)}"
+        directory = (options[:dir] ? options[:dir].to_s : Dir.pwd) +
+                    "/#{Rubex::Compiler.extract_target_name(file)}"
         STDOUT.puts "Warning! you are about to replace contents in the directory '#{directory}', Are you sure? [Yn] "
         confirmation = STDIN.gets.chomp
         force = (confirmation == 'Y')
       end
-      Rubex::Compiler.compile file, directory: options[:dir], force: force, make: options[:install], debug: options[:debug]
+      Rubex::Compiler.compile file, target_dir: options[:dir], force: force,
+                              make: options[:install], debug: options[:debug]
     end
 
-    desc 'install PATH', 'run "make" utility to generate a shared object file required for C extensions'
+    desc 'install PATH',
+         'run "make" utility to generate a shared object file required for C extensions'
     def install(path)
       Rubex::Compiler.run_make path
     end
-
   end
 end

data/lib/rubex/code_supervisor.rb

@@ -0,0 +1,49 @@
+module Rubex
+  # Class for storing Rubex files and their corresponding code writer objects.
+  #   Each file has two code writers - header_writer and code_writer. The
+  #   header_writer stores the file header of the outputted C code (the .h file)
+  #   and the code_writer stores the actual implementation (the .c file).
+  #
+  # It is created only once in the execution of the compiler by the Compiler class.
+  #   Data is stored in the @data class in the form:
+  #   @data = {
+  #     "file1.rubex" => {
+  #       header: header_writer, # Rubex::CodeWriter instance.
+  #       code:   code_writer, # Rubex:: CodeWriter instance.
+  #     },
+  #     "file2.rubex" => {
+  #       header: header_writer, # Rubex::CodeWriter instance.
+  #       code:   code_writer, # Rubex:: CodeWriter instance.
+  #     }
+  #   }
+  class CodeSupervisor
+    def initialize
+      @data = {}
+    end
+
+    def init_file(file_name)
+      header_writer = Rubex::CodeWriter.new(file_name, is_header: true)
+      header_writer << "/*Header file for #{file_name}*/\n\n"
+
+      code_writer = Rubex::CodeWriter.new(file_name)
+      code_writer << "/*Code file for #{file_name}*/\n\n"
+      
+      @data[file_name] = {
+        header: header_writer,
+        code: code_writer
+      }
+    end
+
+    def header(file_name)
+      @data[file_name][:header]
+    end
+
+    def code(file_name)
+      @data[file_name][:code]
+    end
+
+    def files
+      @data.keys
+    end
+  end
+end

data/lib/rubex/code_writer.rb

@@ -2,12 +2,28 @@ module Rubex
   class CodeWriter
     attr_reader :code
 
-    def initialize target_name
+    def initialize target_name, is_header: false
       @code = "/* C extension for #{target_name}.\n"\
                  "This file in generated by Rubex::Compiler. Do not change!\n"\
                  "File generation time: #{Time.now}."\
                "*/\n\n"
       @indent = 0
+      @is_header = is_header
+    end
+
+    def header?
+      @is_header
+    end
+
+    def in_header_guard guard, &block
+      if header?
+        @code << "#ifndef #{guard}\n"
+        @code << "#define #{guard}\n"
+        block.call
+        @code << "#endif\n"
+      else
+        raise "file is not a header file."
+      end
     end
 
     # type - Return type of the method.
@@ -19,6 +35,11 @@ module Rubex
       new_line
     end
 
+    def write_include file_name
+      @code << "#include \"#{file_name}.h\""
+      new_line
+    end
+
     def colon
       @code << ";"
       new_line

data/lib/rubex/compiler.rb

@@ -4,24 +4,73 @@ module Rubex
     CONFIG = Rubex::CompilerConfig.new
 
     class << self
-      def compile path, test: false, directory: nil, force: false, make: false, debug: false
-        tree = ast path, test: test
-        target_name = extract_target_name path
-        code = generate_code tree, target_name
-        ext = extconf target_name, directory: directory
+      # Compile the Rubex file(s) into .c file(s). Do not use this function directly
+      #   unless you're contributing to Rubex. Use the Rake tasks or command line
+      #   interface instead.
+      #
+      # @param path [String] Full path to file. Main file in case of multiple
+      #   file compilation.
+      # @param test [Boolean] false Set to true if compiling rubex files for
+      #   a test case.
+      # @param multi_file [Boolean] false If true, return the CodeSupervisor
+      #   object for code analysis by user. Applicable only if test: opt is true.
+      # @param directory [String] nil Directory where the compiled rubex files
+      #   should be placed.
+      # @param force [Boolean] false If set to true, will forcefully overwrite
+      #    any .c files that were previously generated.
+      # @param make [Boolean] false If true, will automatically generate the .so
+      #    file from compiled C binaries.
+      # @param debug [Boolean] false If true, will compile C programs with gcc
+      #    using the -g option.
+      # @param source_dir [String] nil String specifying the source directory
+      #    inside which the source Rubex files will be placed in case of multi-file
+      #    programs.
+      # @param files [Array[String]] nil An Array specifying the file names to
+      #   compile w.r.t the source_dir directory.
+      #
+      # TODO: The path can be relative to the source_dir if source_dir is specified.
+      def compile path,
+                  test: false,
+                  multi_file: false,
+                  target_dir: nil,
+                  force: false,
+                  make: false,
+                  debug: false,
+                  source_dir: nil,
+                  files: nil
         CONFIG.flush
         CONFIG.debug = debug
-
-        return [tree, code, ext] if test
-        write_files target_name, code, ext, directory: directory, force: force
-        full_path = build_path(directory, target_name)
+        CONFIG.add_link "m" # link cmath libraries
+        target_name = extract_target_name path
+        CONFIG.add_dep target_name
+        
+        tree = ast path, source_dir: source_dir, test: test
+        supervisor = generate_code tree, target_name
+        ext = extconf target_name, target_dir: target_dir
+        
+        if test && !multi_file
+          return [tree, supervisor.code(target_name), ext,
+                  supervisor.header(target_name)]
+        elsif test && multi_file
+          return [tree, supervisor, ext]
+        end
+        write_files target_name, supervisor, ext, target_dir: target_dir, force: force
+        full_path = build_path(target_dir, target_name)
         load_extconf full_path
         run_make full_path if make
       end
 
-      def ast path, test: false
+      # Generate the AST from Rubex source code. Do not use this function unless
+      #   contributing to Rubex. Use CLI or rake tasks instead.
+      #
+      # @param path [String] Full path name of the rubex file.
+      # @param test [Boolean] false Set to true if compiling rubex files for
+      #   a test case.
+      # @param source_dir [String] nil Path of the directory that contains the
+      #   source files.
+      def ast path, test: false, source_dir: nil
         parser = Rubex::Parser.new
-        parser.parse(path)
+        parser.parse(path, source_dir, false)
         parser.do_parse
       rescue Racc::ParseError => e
         raise e if test
@@ -33,40 +82,57 @@ module Rubex
         STDERR.puts error_msg
       end
 
-      def extconf target_name, directory: nil
-        path = build_path(directory, target_name)
+      def extconf target_name, target_dir: nil
+        path = build_path(target_dir, target_name)
         extconf = ""
         extconf << "require 'mkmf'\n"
         extconf << "$libs += \" #{CONFIG.link_flags}\"\n"
         extconf << "$CFLAGS += \" -g \"\n" if CONFIG.debug
+        
+        srcs_config = CONFIG.srcs.map { |s| "\"#{s}\""}.join(',')
+        extconf << "$srcs = [#{srcs_config}]\n"
+
+        objs_config = CONFIG.objs.map { |o| "\"#{o}\""}.join(',')
+        extconf << "$objs = [#{objs_config}]\n"
+        
         extconf << "create_makefile('#{path}/#{target_name}')\n"
         extconf
       end
 
       def generate_code tree, target_name
-        code = Rubex::CodeWriter.new target_name
-        raise "Must be a Rubex::AST::Node, not #{tree.class}" unless
-          tree.is_a? Rubex::AST::Node
-        tree.process_statements target_name, code
-        code
+        supervisor = Rubex::CodeSupervisor.new
+        supervisor.init_file(target_name)
+        raise "Must be a Rubex::AST::Node::MainNode, not #{tree.class}" unless
+          tree.is_a? Rubex::AST::Node::MainNode
+        tree.process_statements target_name, supervisor
+        supervisor
       end
 
       def extract_target_name path
         File.basename(path).split('.')[0]
       end
 
-      def write_files target_name, code, ext, directory: nil, force: false
-        path = build_path(directory, target_name)
+      # Write .c and .h files from the generated C code from rubex files.
+      #
+      # @param target_name [String] Target name of the root file.
+      # @param supervisor [Rubex::CodeSupervisor] Container for code.
+      # @param ext [String] A String representing the extconf file.
+      # @param directory [String] nil Target directory in which files are to be placed.
+      # @param force [Boolean] false Recreate the target directory and rewrite the
+      #   files whether they are already present or not.
+      def write_files target_name, supervisor, ext, target_dir: nil, force: false
+        path = build_path(target_dir, target_name)
         FileUtils.rm_rf(path) if force && Dir.exist?(path)
         Dir.mkdir(path) unless Dir.exist?(path)
 
-        code_file = File.new "#{path}/#{target_name}.c", "w+"
-        code_file.puts code.to_s
-        code_file.close
-
-        extconf_file = File.new "#{path}/extconf.rb", "w+"
-        extconf_file.puts ext
-        extconf_file.close
+        write_to_file "#{path}/#{Rubex::COMMON_UTILS_FILE}.h",
+                      supervisor.header(Rubex::COMMON_UTILS_FILE).to_s
+        supervisor.files.each do |file|
+          write_to_file "#{path}/#{file}.c", supervisor.code(file).to_s
+          write_to_file "#{path}/#{file}.h", supervisor.header(file).to_s
+        end
+        
+        write_to_file "#{path}/extconf.rb", ext
       end
 
       def load_extconf path
@@ -81,13 +147,26 @@ module Rubex
         end
       end
 
+      # Create build path for outputting .c and .h files. Will check whether the calling
+      #   process is a rake task or cmd.
+      #
+      # @param directory [String] The directory inside which this build path will exist.
+      # @param target_name [String] Name of the folder inside the directory.
       def build_path directory, target_name
         directory = (directory ? directory.to_s : Dir.pwd)
-        unless directory.end_with?(target_name)
-          directory += "/#{target_name}"
-        end
+       unless directory.end_with?(target_name)
+         directory += "/#{target_name}"
+       end
         directory
       end
+      
+      private
+
+      def write_to_file path, contents
+        f = File.new path, "w+"
+        f.puts contents
+        f.close
+      end
     end
   end
 end

data/lib/rubex/compiler_config.rb

@@ -1,9 +1,14 @@
 module Rubex
+  # Class for storing configuration of the compiler (gcc) that will compile
+  #   the generated C code. This includes file names, compiler flags and other
+  #   options required by Rubex.
   class CompilerConfig
-    attr_accessor :debug
+    attr_accessor :debug, :srcs, :objs
     
     def initialize
       @links = []
+      @srcs = []
+      @objs = []
     end
 
     def add_link link_str
@@ -16,6 +21,14 @@ module Rubex
 
     def flush
       @links = []
+      @srcs = []
+      @objs = []
+    end
+
+    # add dependency on file so extconf will recognise it.
+    def add_dep(file_name)
+      @srcs << "#{file_name}.c"
+      @objs << "#{file_name}.o"
     end
   end
 end

data/lib/rubex/constants.rb

@@ -15,6 +15,9 @@ module Rubex
 
   ACTUAL_ARGS_SUFFIX = "_actual_args"
 
+  COMMON_UTILS_CONST = RUBEX_PREFIX + "_COMMON_UTILS_H"
+  COMMON_UTILS_FILE = RUBEX_PREFIX + "_common_utils_"
+
   TYPE_MAPPINGS = {
     'char'                   => Rubex::DataType::Char,
     'bool'                   => Rubex::DataType::CBoolean,

data/lib/rubex/data_type.rb

@@ -1,7 +1,6 @@
 require_relative 'data_type_helpers/helpers'
-Dir['./lib/rubex/data_type_helpers/**/*.rb'].sort.each { |f| require f }
-Dir['./lib/rubex/data_type/**/*.rb'].sort.each { |f| require f }
-
+Dir[File.join(File.dirname(File.dirname(__FILE__)), "rubex", "data_type_helpers", "**", "*.rb" )].sort.each { |f| require f }
+Dir[File.join(File.dirname(File.dirname(__FILE__)), "rubex", "data_type", "**", "*.rb" )].sort.each { |f| require f }
 # TODO: How to store this in a Ruby class? Use BigDecimal?
 # class LF64
 #   def to_s; "long double"; end

data/lib/rubex/data_type/ruby_object/ruby_symbol.rb

@@ -5,6 +5,5 @@ module Rubex
         true
       end
     end
-
   end
 end

data/lib/rubex/error.rb

@@ -12,4 +12,8 @@ module Rubex
   class TypeError < StandardError; end
 
   class LibraryNotFoundError < StandardError; end
+
+  class CompileCheckError < StandardError; end
+
+  class FileNotFoundError < StandardError; end
 end

data/lib/rubex/helpers/writers.rb

@@ -29,9 +29,8 @@ module Rubex
         end
       end
 
-      def declare_types(code, scope)
-        scope.type_entries.each do |entry|
-          # if !entry.extern
+      def declare_types(code, type_entries)
+        type_entries.each do |entry|
           type = entry.type
 
           if type.alias_type?
@@ -54,7 +53,6 @@ module Rubex
             end
           end
           code.nl
-          # end
         end
       end
 
@@ -74,6 +72,37 @@ module Rubex
           code.declare_variable type: var.type.to_s, c_name: var.c_name
         end
       end
+
+      def write_usability_macros(code)
+        code.nl
+        code.c_macro Rubex::RUBEX_PREFIX + 'INT2BOOL(arg) (arg ? Qtrue : Qfalse)'
+        code.nl
+      end
+
+      def write_usability_functions_header(header)
+        header.nl
+        write_char_2_ruby_str_header header
+      end
+
+      def write_usability_functions_code(code)
+        code.nl
+        write_char_2_ruby_str_code(code)
+      end
+
+      def write_char_2_ruby_str_header(header)
+        header.nl
+        header << "VALUE #{Rubex::C_FUNC_CHAR2RUBYSTR}(char ch);"
+      end
+
+      def write_char_2_ruby_str_code(code)
+        code << "VALUE #{Rubex::C_FUNC_CHAR2RUBYSTR}(char ch)"
+        code.block do
+          code << "char s[2];\n"
+          code << "s[0] = ch;\n"
+          code << "s[1] = '\\0';\n"
+          code << "return rb_str_new2(s);\n"
+        end
+      end
     end
   end
 end

data/lib/rubex/lexer.rex

@@ -29,8 +29,11 @@ macros
   NULL            /NULL/
   ATTACH          /attach/
   BLOCK_GIVEN     /block_given\?/
+  NO_GIL          /no_gil/
+  REQUIRE_RUBEX   /require_rubex/
 
   IDENTIFIER      /[a-zA-Z_][a-zA-Z_0-9]*/
+  COLON2          /::/
   LPAREN          /\(/
   RPAREN          /\)/
   LSQUARE         /\[/
@@ -126,6 +129,7 @@ rules
   # Method hacks
 
   /data\$/                { [:kDATA_VAR, text] }
+  /#{REQUIRE_RUBEX}/       { [:kREQUIRE_RUBEX, text] }
   /#{DOT}#{EACH}/ { [:kDOT_EACH, text] }
 
   # Data Types
@@ -144,8 +148,10 @@ rules
   /#{STRUCT}\ / { [:kSTRUCT, text] }
   /#{UNION}\ /  { [:kUNION, text]  }
   /#{ALIAS}\ /  { [:kALIAS, text]  }
+  /#{NO_GIL}/   { [:kNO_GIL, text] }
 
   /:#{IDENTIFIER}/        { [:tSYMBOL, text] }
+  /@#{IDENTIFIER}/        { [:tINSTANCE_VAR, text] }
   /#{IDENTIFIER}/         { [:tIDENTIFIER, text] }
   /#{LBRACE}/             { [:tLBRACE, text] }
   /#{RBRACE}/             { [:tRBRACE, text] }
@@ -158,21 +164,23 @@ rules
   /#{NL}/                 { [:tNL, text] }
   /#{QMARK}/              { [:tQMARK, text]}
   /#{DOT}/                { [:tDOT, text]    }
+  /#{COLON2}/             { [:tCOLON2, text]  }
   /#{COLON}/              { [:tCOLON, text]  }
 
   # operators
 
+  /#{EXPOASSIGN}/       { [:tOP_ASSIGN, text]}
   /#{PLUSASSIGN}/       { [:tOP_ASSIGN, text]}
   /#{MINUSASSIGN}/      { [:tOP_ASSIGN, text]}
   /#{STARASSIGN}/       { [:tOP_ASSIGN, text]}
   /#{DIVIDEASSIGN}/     { [:tOP_ASSIGN, text]}
   /#{EXPOASSIGN}/       { [:tOP_ASSIGN, text]}
   /#{MODULUSASSIGN}/    { [:tOP_ASSIGN, text]}
+  /#{EXPO}/             { [:tEXPO, text]}
   /#{PLUS}/             { [:tPLUS, text]}
   /#{MINUS}/            { [:tMINUS, text]}
   /#{STAR}/             { [:tSTAR, text]}
   /#{DIVIDE}/           { [:tDIVIDE, text]}
-  /#{EXPO}/             { [:tEXPO, text]}
   /#{MODULUS}/          { [:tMODULUS, text]}
   /#{EXPO}/             { [:tEXPO, text]}
   /#{EQ}/               { [:tEQ, text]  }