nilac 0.0.4.3.0 → 0.0.4.3.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c3f566c76264dbd8ac2ebae19881d66ef275f331
+  data.tar.gz: a06a5560e01677ced9c242d89c92c7cbf3840d05
+SHA512:
+  metadata.gz: 0c4a4b86198e3513a73a477c726810e2fd1f579311677e6c5af00d4442a2b2ca878a2f4cf9fd51da9e1921f81b05d82e6dca2269f0e4cc2fabd64dd9b37c19df
+  data.tar.gz: 3382cb6fa6a92a6a905e73c36c1f358ddeb4b9d67ae06152876eb755f53624bc0fd0457453db9378bba33c95d70f7bdf810784068c07d7c9aaee300f4c549942

data/bin/nilac

@@ -333,6 +333,8 @@ def compile(input_file_path, *output_file_name)
 
             test_string = string_extract[0..closed_curly_brace_index[0]]
 
+            puts test_string
+
             original_string = test_string.dup
 
             if test_string.include?("{")
@@ -606,6 +608,50 @@ def compile(input_file_path, *output_file_name)
 
   def compile_parallel_assignment(input_file_contents, temporary_nila_file)
 
+    def arrayify_right_side(input_string)
+
+      javascript_regexp = /(if |while |for |function |function\()/
+
+      if input_string.include?("=") and input_string.index(javascript_regexp) == nil and input_string.strip[0..3] != "_ref" and !input_string.split("=")[1].include?("[")
+
+        modified_input_string = input_string.dup
+
+        right_side = input_string.split("=")[1]
+
+        if right_side.include?(",")
+
+          splits = right_side.split(",")
+
+          replacement_string = []
+
+          splits.each do |str|
+
+            unless str.include?(")") and !str.include?("(")
+
+              replacement_string << str
+
+            else
+
+              replacement_string[-1] = replacement_string[-1]+ "," +str
+
+            end
+
+          end
+
+          replacement_string = " [#{replacement_string.join(",").strip}]\n"
+
+          input_string = input_string.sub(right_side,replacement_string)
+
+        end
+
+      end
+
+      return input_string
+
+    end
+
+    input_file_contents = input_file_contents.collect {|element| arrayify_right_side(element)}
+
     possible_variable_lines = input_file_contents.reject { |element| !element.include? "=" }
 
     possible_parallel_assignment = possible_variable_lines.reject { |element| !element.split("=")[0].include? "," }
@@ -798,8 +844,24 @@ def compile(input_file_path, *output_file_name)
 
     line_by_line_contents = read_file_line_by_line(temporary_nila_file)
 
+    for_loop_variables = []
+
+    for_loop_statements = line_by_line_contents.reject {|line| !line.include?("for")}
+
+    for_loop_statements.each do |statement|
+
+      varis = statement.split("for (")[1].split(";",2)[0].split(",")
+
+      for_loop_variables << varis.collect {|vari| vari.strip.split("=")[0].strip}
+
+      for_loop_variables = for_loop_variables.flatten
+
+    end
+
     variables += loop_variables
 
+    variables += for_loop_variables
+
     variables = variables.flatten
 
     if variables.length > 0
@@ -1900,7 +1962,8 @@ def compile(input_file_path, *output_file_name)
 
         "p" => "console.log",
 
-        "print" => "process.stdout.write"
+        "print" => "process.stdout.write",
+
     }
 
     function_map = function_map_replacements.keys
@@ -1925,6 +1988,46 @@ def compile(input_file_path, *output_file_name)
 
   end
 
+  def compile_ruby_methods(input_file_contents)
+
+    # These are some interesting methods that we really miss in Javascript.
+    # So we have made these methods available
+
+    method_map_replacement = {
+
+        ".split" => ".split(\" \")",
+
+        ".strip" => ".replace(/^\s+|\s+$/g,'')",
+
+        ".lstrip" => ".replace(/^\s+/g,\"\")",
+
+        ".rstrip" => ".replace(/\s+$/g,\"\")"
+    }
+
+    method_map = method_map_replacement.keys
+
+    method_map_regex = method_map.collect {|name| name.gsub(".","\\.")}
+
+    method_map_regex = Regexp.new(method_map_regex.join("|"))
+
+    modified_file_contents = input_file_contents.clone
+
+    input_file_contents.each_with_index do |line, index|
+
+      if line.match(method_map_regex)
+
+        unless method_match.include?(line+"(")
+
+          puts line
+
+        end
+
+      end
+
+    end
+
+  end
+
   def compile_whitespace_delimited_functions(input_file_contents, function_names, temporary_nila_file)
 
     def extract(input_string, pattern_start, pattern_end)
@@ -2713,6 +2816,322 @@ def compile(input_file_path, *output_file_name)
 
     end
 
+    def compile_regular_for(input_file_contents, temporary_nila_file)
+
+      def convert_string_to_array(input_string, temporary_nila_file)
+
+        file_id = open(temporary_nila_file, 'w')
+
+        file_id.write(input_string)
+
+        file_id.close()
+
+        line_by_line_contents = read_file_line_by_line(temporary_nila_file)
+
+        return line_by_line_contents
+
+      end
+
+      def extract_for_blocks(for_statement_indexes, input_file_contents)
+
+        possible_for_blocks = []
+
+        for_block_counter = 0
+
+        extracted_blocks = []
+
+        controlregexp = /(if |while |def |for )/
+
+        rejectionregexp = /( if | while )/
+
+        for x in 0...for_statement_indexes.length-1
+
+          possible_for_blocks << input_file_contents[for_statement_indexes[x]..for_statement_indexes[x+1]]
+
+        end
+
+        end_counter = 0
+
+        end_index = []
+
+        current_block = []
+
+        possible_for_blocks.each_with_index do |block|
+
+          current_block += block
+
+          current_block.each_with_index do |line, index|
+
+            if line.strip.eql? "end"
+
+              end_counter += 1
+
+              end_index << index
+
+            end
+
+          end
+
+          if end_counter > 0
+
+            until end_index.empty?
+
+              array_extract = current_block[0..end_index[0]].reverse
+
+              index_counter = 0
+
+              array_extract.each_with_index do |line|
+
+                break if (line.lstrip.index(controlregexp) != nil and line.lstrip.index(rejectionregexp).nil?)
+
+                index_counter += 1
+
+              end
+
+              block_extract = array_extract[0..index_counter].reverse
+
+              extracted_blocks << block_extract
+
+              block_start = current_block.index(block_extract[0])
+
+              block_end = current_block.index(block_extract[-1])
+
+              current_block[block_start..block_end] = "--forblock#{for_block_counter}"
+
+              for_block_counter += 1
+
+              end_counter = 0
+
+              end_index = []
+
+              current_block.each_with_index do |line, index|
+
+                if line.strip.eql? "end"
+
+                  end_counter += 1
+
+                  end_index << index
+
+                end
+
+              end
+
+            end
+
+          end
+
+        end
+
+        return current_block, extracted_blocks
+
+      end
+
+      def compile_for_syntax(input_block)
+
+        def compile_condition(input_condition, input_block)
+
+          variable,array_name = input_condition.split("in")
+
+          if array_name.strip.include?("[") and array_name.strip.include?("]")
+
+            replacement_array = "_ref1 = #{array_name.strip}\n\n"
+
+            replacement_string = "#{variable.strip} = _ref1[_i];\n\n"
+
+            input_block = [replacement_array] + input_block.insert(1,replacement_string)
+
+            input_block[1] = "for (_i = 0, _j = _ref1.length; _i < _j; _i += 1) {\n\n"
+
+          elsif array_name.strip.include?("..")
+
+            array_type = if array_name.strip.include?("...") then 0 else 1 end
+
+            if array_type == 0
+
+              num1,num2 = array_name.strip.split("...")
+
+              input_block[0] = "for (#{variable.strip} = #{num1}, _j = #{num2}; #{variable.strip} <= _j; #{variable.strip} += 1) {\n\n"
+
+            else
+
+              num1,num2 = array_name.strip.split("..")
+
+              input_block[0] = "for (#{variable.strip} = #{num1}, _j = #{num2}; #{variable.strip} < _j; #{variable.strip} += 1) {\n\n"
+
+            end
+
+          else
+
+            input_block[0] = "for (_i = 0, _j = #{array_name.strip}.length; _i < _j; _i += 1) {\n\n"
+
+            input_block = input_block.insert(1,"#{variable.strip} = #{array_name.strip}[_i];\n\n")
+
+          end
+
+          return input_block
+
+        end
+
+        modified_input_block = input_block.dup
+
+        strings = []
+
+        string_counter = 0
+
+        input_block.each_with_index do |line, index|
+
+          if line.include?("\"")
+
+            opening_quotes = line.index("\"")
+
+            string_extract = line[opening_quotes..line.index("\"", opening_quotes+1)]
+
+            strings << string_extract
+
+            modified_input_block[index] = modified_input_block[index].sub(string_extract, "--string{#{string_counter}}")
+
+            string_counter += 1
+
+          end
+
+        end
+
+        input_block = modified_input_block
+
+        starting_line = input_block[0]
+
+        starting_line = starting_line + "\n" if starting_line.lstrip == starting_line
+
+        junk, condition = starting_line.split("for")
+
+        input_block[-1] = input_block[-1].lstrip.sub("end", "}")
+
+        input_block = compile_condition(condition,input_block)
+
+        modified_input_block = input_block.dup
+
+        input_block.each_with_index do |line, index|
+
+          if line.include?("--string{")
+
+            junk, remains = line.split("--string{")
+
+            string_index, junk = remains.split("}")
+
+            modified_input_block[index] = modified_input_block[index].sub("--string{#{string_index.strip}}", strings[string_index.strip.to_i])
+
+          end
+
+        end
+
+        return modified_input_block
+
+      end
+
+      possible_for_statements = input_file_contents.reject { |element| !element.include?("for") }
+
+      possible_for_statements = possible_for_statements.reject {|element| element.include?("for (")}
+
+      if !possible_for_statements.empty?
+
+        for_statement_indexes = []
+
+        possible_for_statements.each do |statement|
+
+          for_statement_indexes << input_file_contents.dup.each_index.select { |index| input_file_contents[index] == statement }
+
+        end
+
+        for_statement_indexes = [0] + for_statement_indexes.flatten + [-1]
+
+        controlregexp = /(if |def |while )/
+
+        modified_input_contents, extracted_statements = extract_for_blocks(for_statement_indexes, input_file_contents.clone)
+
+        joined_blocks = extracted_statements.collect { |element| element.join }
+
+        for_statements = joined_blocks.reject { |element| element.index(controlregexp) != nil }
+
+        rejected_elements = joined_blocks - for_statements
+
+        rejected_elements_index = []
+
+        rejected_elements.each do |element|
+
+          rejected_elements_index << joined_blocks.each_index.select { |index| joined_blocks[index] == element }
+
+        end
+
+        for_blocks_index = (0...extracted_statements.length).to_a
+
+        rejected_elements_index = rejected_elements_index.flatten
+
+        for_blocks_index -= rejected_elements_index
+
+        modified_for_statements = for_statements.collect { |string| convert_string_to_array(string, temporary_nila_file) }
+
+        modified_for_statements = modified_for_statements.collect { |block| compile_for_syntax(block) }.reverse
+
+        for_blocks_index = for_blocks_index.collect { |element| "--forblock#{element}" }.reverse
+
+        rejected_elements_index = rejected_elements_index.collect { |element| "--forblock#{element}" }.reverse
+
+        rejected_elements = rejected_elements.reverse
+
+        joined_file_contents = modified_input_contents.join
+
+        until for_blocks_index.empty? and rejected_elements_index.empty?
+
+          if !for_blocks_index.empty?
+
+            if joined_file_contents.include?(for_blocks_index[0])
+
+              joined_file_contents = joined_file_contents.sub(for_blocks_index[0], modified_for_statements[0].join)
+
+              for_blocks_index.delete_at(0)
+
+              modified_for_statements.delete_at(0)
+
+            else
+
+              joined_file_contents = joined_file_contents.sub(rejected_elements_index[0], rejected_elements[0].join)
+
+              rejected_elements_index.delete_at(0)
+
+              rejected_elements.delete_at(0)
+
+            end
+
+          else
+
+            joined_file_contents = joined_file_contents.sub(rejected_elements_index[0], rejected_elements[0].join)
+
+            rejected_elements_index.delete_at(0)
+
+            rejected_elements.delete_at(0)
+
+          end
+
+        end
+
+      else
+
+        joined_file_contents = input_file_contents.join
+
+      end
+
+      file_id = open(temporary_nila_file, 'w')
+
+      file_id.write(joined_file_contents)
+
+      file_id.close()
+
+      line_by_line_contents = read_file_line_by_line(temporary_nila_file)
+
+      return line_by_line_contents
+
+    end
+
     def compile_loop_keyword(input_file_contents,temporary_nila_file)
 
       def convert_string_to_array(input_string, temporary_nila_file)
@@ -3051,12 +3470,16 @@ def compile(input_file_path, *output_file_name)
 
     file_contents = compile_ternary_if(input_file_contents)
 
+    puts file_contents
+
     file_contents, rejected_lines = ignore_statement_modifiers(file_contents)
 
     file_contents = replace_unless_until(file_contents)
 
     file_contents = compile_regular_if(file_contents, temporary_nila_file)
 
+    file_contents = compile_regular_for(file_contents, temporary_nila_file)
+
     file_contents = compile_regular_while(file_contents, temporary_nila_file)
 
     file_contents = compile_loop_keyword(file_contents,temporary_nila_file)
@@ -3083,7 +3506,7 @@ def compile(input_file_path, *output_file_name)
 
       end
 
-      def extract_variable_names(input_file_contents, temporary_nila_file)
+      def extract_variable_names(input_file_contents)
 
         variables = []
 
@@ -3169,9 +3592,9 @@ def compile(input_file_path, *output_file_name)
 
           file_extract = input_file_contents[0..index_counter]
 
-          file_variables = extract_variable_names(file_extract,temporary_nila_file)
+          file_variables = extract_variable_names(file_extract)
 
-          block_variables = extract_variable_names(loop_extract,temporary_nila_file)
+          block_variables = extract_variable_names(loop_extract)
 
           var_need_of_declaration = file_variables-block_variables-["_i","_j"]
 
@@ -3987,10 +4410,6 @@ def compile(input_file_path, *output_file_name)
 
     file_contents = compile_conditional_structures(file_contents, temp_file)
 
-    file_contents = compile_arrays(file_contents, temp_file)
-
-    file_contents = compile_strings(file_contents)
-
     file_contents = compile_integers(file_contents)
 
     file_contents = compile_default_values(file_contents, temp_file)
@@ -4001,12 +4420,18 @@ def compile(input_file_path, *output_file_name)
 
     file_contents = compile_parallel_assignment(file_contents, temp_file)
 
+    file_contents = compile_arrays(file_contents, temp_file)
+
+    file_contents = compile_strings(file_contents)
+
     file_contents, function_names = compile_named_functions(file_contents, named_functions, nested_functions, temp_file)
 
     list_of_variables, file_contents = get_variables(file_contents, temp_file,loop_vars)
 
     file_contents, ruby_functions = compile_custom_function_map(file_contents)
 
+    #compile_ruby_methods(file_contents)
+
     function_names << ruby_functions
 
     list_of_variables += loop_vars
@@ -4089,7 +4514,7 @@ def find_file_path(input_path, file_extension)
 
 end
 
-nilac_version = "0.0.4.3.0"
+nilac_version = "0.0.4.3.3"
 
 opts = Slop.parse do
   on :c, :compile=, 'Compile Nila File', as:Array, delimiter:":"

data/lib/nilac/version.rb

@@ -1,3 +1,3 @@
 module Nilac
-  VERSION = "0.0.4.3.0"
+  VERSION = "0.0.4.3.3"
 end

data/shark/features/regular_for.feature

@@ -0,0 +1,11 @@
+Feature: Compiling for loops in a nila program
+  Scenario: Input with several kinds of for loops
+    Given the input file "regular_for.nila"
+    When the ~compiler is run
+    The output file must be "regular_for.js"
+    The output file must equal "correct_for.js"
+
+Configurations:
+
+~compiler => src/nilac.rb
+:v $cliusage => ruby :v --compile $file

data/shark/test_files/correct_for.js

@@ -0,0 +1,27 @@
+//Written using Nila. Visit http://adhithyan15.github.io/nila
+(function() {
+  var _i, _j, _ref1, fruit, fruits, x;
+
+  _ref1 = [1,2,3,4];
+
+  for (_i = 0, _j = _ref1.length; _i < _j; _i += 1) {
+    x = _ref1[_i];
+    console.log(x);
+  }
+
+  for (x = 0, _j = 5; x <= _j; x += 1) {
+    console.log(x);
+  }
+
+  for (x = 0, _j = 5; x < _j; x += 1) {
+    console.log(x);
+  }
+
+  fruits = ['Apple','Banana', 'Mango'];
+
+  for (_i = 0, _j = fruits.length; _i < _j; _i += 1) {
+    fruit = fruits[_i];
+    console.log(fruit);
+  }
+
+}).call(this);

data/shark/test_files/correct_initialization.js

@@ -1,6 +1,6 @@
 //Written using Nila. Visit http://adhithyan15.github.io/nila
 (function() {
-  var _ref1, first_name, last_name, name_split, parse_name;
+  var _ref1, count, current_val, first_name, last_name, name_split, name_split1, name_split2, next_val, parse_name;
 
   // This file demonstrates multiple variable initialization
 
@@ -18,4 +18,18 @@
 
   console.log(first_name + " " + last_name);
 
+  _ref1 = [0, 1, 1];
+
+  current_val = _ref1[0];
+
+  next_val = _ref1[1];
+
+  count = _ref1[2];
+
+  _ref1 = ["Adhithya Rajasekaran".split((" "),1),"Adhithya Rajasekaran".split(" ",2)];
+
+  name_split1 = _ref1[0];
+
+  name_split2 = _ref1[1];
+
 }).call(this);

data/shark/test_files/multiple_initialization.nila

@@ -11,3 +11,7 @@ end
 first_name,last_name = parse_name("Adhithya Rajasekaran")
 
 puts first_name + " " + last_name
+
+current_val, next_val, count = 0, 1, 1
+
+name_split1,name_split2 = "Adhithya Rajasekaran".split((" "),1),"Adhithya Rajasekaran".split(" ",2)

data/shark/test_files/regular_for.nila

@@ -0,0 +1,17 @@
+for x in [1,2,3,4]
+  puts x
+end
+
+for x in 0...5
+  puts x
+end
+
+for x in 0..5
+  puts x
+end
+
+fruits = ['Apple','Banana', 'Mango']
+
+for fruit in fruits
+  puts fruit
+end

data/shark/test_files/times.nila

@@ -10,4 +10,4 @@ a = 5
 
   puts "Twice the number is #{2*n}"
 
-end
+end

data/src/nilac.rb

@@ -331,6 +331,8 @@ def compile(input_file_path, *output_file_name)
 
             test_string = string_extract[0..closed_curly_brace_index[0]]
 
+            puts test_string
+
             original_string = test_string.dup
 
             if test_string.include?("{")
@@ -604,6 +606,50 @@ def compile(input_file_path, *output_file_name)
 
   def compile_parallel_assignment(input_file_contents, temporary_nila_file)
 
+    def arrayify_right_side(input_string)
+
+      javascript_regexp = /(if |while |for |function |function\()/
+
+      if input_string.include?("=") and input_string.index(javascript_regexp) == nil and input_string.strip[0..3] != "_ref" and !input_string.split("=")[1].include?("[")
+
+        modified_input_string = input_string.dup
+
+        right_side = input_string.split("=")[1]
+
+        if right_side.include?(",")
+
+          splits = right_side.split(",")
+
+          replacement_string = []
+
+          splits.each do |str|
+
+            unless str.include?(")") and !str.include?("(")
+
+              replacement_string << str
+
+            else
+
+              replacement_string[-1] = replacement_string[-1]+ "," +str
+
+            end
+
+          end
+
+          replacement_string = " [#{replacement_string.join(",").strip}]\n"
+
+          input_string = input_string.sub(right_side,replacement_string)
+
+        end
+
+      end
+
+      return input_string
+
+    end
+
+    input_file_contents = input_file_contents.collect {|element| arrayify_right_side(element)}
+
     possible_variable_lines = input_file_contents.reject { |element| !element.include? "=" }
 
     possible_parallel_assignment = possible_variable_lines.reject { |element| !element.split("=")[0].include? "," }
@@ -796,8 +842,24 @@ def compile(input_file_path, *output_file_name)
 
     line_by_line_contents = read_file_line_by_line(temporary_nila_file)
 
+    for_loop_variables = []
+
+    for_loop_statements = line_by_line_contents.reject {|line| !line.include?("for")}
+
+    for_loop_statements.each do |statement|
+
+      varis = statement.split("for (")[1].split(";",2)[0].split(",")
+
+      for_loop_variables << varis.collect {|vari| vari.strip.split("=")[0].strip}
+
+      for_loop_variables = for_loop_variables.flatten
+
+    end
+
     variables += loop_variables
 
+    variables += for_loop_variables
+
     variables = variables.flatten
 
     if variables.length > 0
@@ -1898,7 +1960,8 @@ def compile(input_file_path, *output_file_name)
 
         "p" => "console.log",
 
-        "print" => "process.stdout.write"
+        "print" => "process.stdout.write",
+
     }
 
     function_map = function_map_replacements.keys
@@ -1923,6 +1986,46 @@ def compile(input_file_path, *output_file_name)
 
   end
 
+  def compile_ruby_methods(input_file_contents)
+
+    # These are some interesting methods that we really miss in Javascript.
+    # So we have made these methods available
+
+    method_map_replacement = {
+
+        ".split" => ".split(\" \")",
+
+        ".strip" => ".replace(/^\s+|\s+$/g,'')",
+
+        ".lstrip" => ".replace(/^\s+/g,\"\")",
+
+        ".rstrip" => ".replace(/\s+$/g,\"\")"
+    }
+
+    method_map = method_map_replacement.keys
+
+    method_map_regex = method_map.collect {|name| name.gsub(".","\\.")}
+
+    method_map_regex = Regexp.new(method_map_regex.join("|"))
+
+    modified_file_contents = input_file_contents.clone
+
+    input_file_contents.each_with_index do |line, index|
+
+      if line.match(method_map_regex)
+
+        unless method_match.include?(line+"(")
+
+          puts line
+
+        end
+
+      end
+
+    end
+
+  end
+
   def compile_whitespace_delimited_functions(input_file_contents, function_names, temporary_nila_file)
 
     def extract(input_string, pattern_start, pattern_end)
@@ -2711,6 +2814,322 @@ def compile(input_file_path, *output_file_name)
 
     end
 
+    def compile_regular_for(input_file_contents, temporary_nila_file)
+
+      def convert_string_to_array(input_string, temporary_nila_file)
+
+        file_id = open(temporary_nila_file, 'w')
+
+        file_id.write(input_string)
+
+        file_id.close()
+
+        line_by_line_contents = read_file_line_by_line(temporary_nila_file)
+
+        return line_by_line_contents
+
+      end
+
+      def extract_for_blocks(for_statement_indexes, input_file_contents)
+
+        possible_for_blocks = []
+
+        for_block_counter = 0
+
+        extracted_blocks = []
+
+        controlregexp = /(if |while |def |for )/
+
+        rejectionregexp = /( if | while )/
+
+        for x in 0...for_statement_indexes.length-1
+
+          possible_for_blocks << input_file_contents[for_statement_indexes[x]..for_statement_indexes[x+1]]
+
+        end
+
+        end_counter = 0
+
+        end_index = []
+
+        current_block = []
+
+        possible_for_blocks.each_with_index do |block|
+
+          current_block += block
+
+          current_block.each_with_index do |line, index|
+
+            if line.strip.eql? "end"
+
+              end_counter += 1
+
+              end_index << index
+
+            end
+
+          end
+
+          if end_counter > 0
+
+            until end_index.empty?
+
+              array_extract = current_block[0..end_index[0]].reverse
+
+              index_counter = 0
+
+              array_extract.each_with_index do |line|
+
+                break if (line.lstrip.index(controlregexp) != nil and line.lstrip.index(rejectionregexp).nil?)
+
+                index_counter += 1
+
+              end
+
+              block_extract = array_extract[0..index_counter].reverse
+
+              extracted_blocks << block_extract
+
+              block_start = current_block.index(block_extract[0])
+
+              block_end = current_block.index(block_extract[-1])
+
+              current_block[block_start..block_end] = "--forblock#{for_block_counter}"
+
+              for_block_counter += 1
+
+              end_counter = 0
+
+              end_index = []
+
+              current_block.each_with_index do |line, index|
+
+                if line.strip.eql? "end"
+
+                  end_counter += 1
+
+                  end_index << index
+
+                end
+
+              end
+
+            end
+
+          end
+
+        end
+
+        return current_block, extracted_blocks
+
+      end
+
+      def compile_for_syntax(input_block)
+
+        def compile_condition(input_condition, input_block)
+
+          variable,array_name = input_condition.split("in")
+
+          if array_name.strip.include?("[") and array_name.strip.include?("]")
+
+            replacement_array = "_ref1 = #{array_name.strip}\n\n"
+
+            replacement_string = "#{variable.strip} = _ref1[_i];\n\n"
+
+            input_block = [replacement_array] + input_block.insert(1,replacement_string)
+
+            input_block[1] = "for (_i = 0, _j = _ref1.length; _i < _j; _i += 1) {\n\n"
+
+          elsif array_name.strip.include?("..")
+
+            array_type = if array_name.strip.include?("...") then 0 else 1 end
+
+            if array_type == 0
+
+              num1,num2 = array_name.strip.split("...")
+
+              input_block[0] = "for (#{variable.strip} = #{num1}, _j = #{num2}; #{variable.strip} <= _j; #{variable.strip} += 1) {\n\n"
+
+            else
+
+              num1,num2 = array_name.strip.split("..")
+
+              input_block[0] = "for (#{variable.strip} = #{num1}, _j = #{num2}; #{variable.strip} < _j; #{variable.strip} += 1) {\n\n"
+
+            end
+
+          else
+
+            input_block[0] = "for (_i = 0, _j = #{array_name.strip}.length; _i < _j; _i += 1) {\n\n"
+
+            input_block = input_block.insert(1,"#{variable.strip} = #{array_name.strip}[_i];\n\n")
+
+          end
+
+          return input_block
+
+        end
+
+        modified_input_block = input_block.dup
+
+        strings = []
+
+        string_counter = 0
+
+        input_block.each_with_index do |line, index|
+
+          if line.include?("\"")
+
+            opening_quotes = line.index("\"")
+
+            string_extract = line[opening_quotes..line.index("\"", opening_quotes+1)]
+
+            strings << string_extract
+
+            modified_input_block[index] = modified_input_block[index].sub(string_extract, "--string{#{string_counter}}")
+
+            string_counter += 1
+
+          end
+
+        end
+
+        input_block = modified_input_block
+
+        starting_line = input_block[0]
+
+        starting_line = starting_line + "\n" if starting_line.lstrip == starting_line
+
+        junk, condition = starting_line.split("for")
+
+        input_block[-1] = input_block[-1].lstrip.sub("end", "}")
+
+        input_block = compile_condition(condition,input_block)
+
+        modified_input_block = input_block.dup
+
+        input_block.each_with_index do |line, index|
+
+          if line.include?("--string{")
+
+            junk, remains = line.split("--string{")
+
+            string_index, junk = remains.split("}")
+
+            modified_input_block[index] = modified_input_block[index].sub("--string{#{string_index.strip}}", strings[string_index.strip.to_i])
+
+          end
+
+        end
+
+        return modified_input_block
+
+      end
+
+      possible_for_statements = input_file_contents.reject { |element| !element.include?("for") }
+
+      possible_for_statements = possible_for_statements.reject {|element| element.include?("for (")}
+
+      if !possible_for_statements.empty?
+
+        for_statement_indexes = []
+
+        possible_for_statements.each do |statement|
+
+          for_statement_indexes << input_file_contents.dup.each_index.select { |index| input_file_contents[index] == statement }
+
+        end
+
+        for_statement_indexes = [0] + for_statement_indexes.flatten + [-1]
+
+        controlregexp = /(if |def |while )/
+
+        modified_input_contents, extracted_statements = extract_for_blocks(for_statement_indexes, input_file_contents.clone)
+
+        joined_blocks = extracted_statements.collect { |element| element.join }
+
+        for_statements = joined_blocks.reject { |element| element.index(controlregexp) != nil }
+
+        rejected_elements = joined_blocks - for_statements
+
+        rejected_elements_index = []
+
+        rejected_elements.each do |element|
+
+          rejected_elements_index << joined_blocks.each_index.select { |index| joined_blocks[index] == element }
+
+        end
+
+        for_blocks_index = (0...extracted_statements.length).to_a
+
+        rejected_elements_index = rejected_elements_index.flatten
+
+        for_blocks_index -= rejected_elements_index
+
+        modified_for_statements = for_statements.collect { |string| convert_string_to_array(string, temporary_nila_file) }
+
+        modified_for_statements = modified_for_statements.collect { |block| compile_for_syntax(block) }.reverse
+
+        for_blocks_index = for_blocks_index.collect { |element| "--forblock#{element}" }.reverse
+
+        rejected_elements_index = rejected_elements_index.collect { |element| "--forblock#{element}" }.reverse
+
+        rejected_elements = rejected_elements.reverse
+
+        joined_file_contents = modified_input_contents.join
+
+        until for_blocks_index.empty? and rejected_elements_index.empty?
+
+          if !for_blocks_index.empty?
+
+            if joined_file_contents.include?(for_blocks_index[0])
+
+              joined_file_contents = joined_file_contents.sub(for_blocks_index[0], modified_for_statements[0].join)
+
+              for_blocks_index.delete_at(0)
+
+              modified_for_statements.delete_at(0)
+
+            else
+
+              joined_file_contents = joined_file_contents.sub(rejected_elements_index[0], rejected_elements[0].join)
+
+              rejected_elements_index.delete_at(0)
+
+              rejected_elements.delete_at(0)
+
+            end
+
+          else
+
+            joined_file_contents = joined_file_contents.sub(rejected_elements_index[0], rejected_elements[0].join)
+
+            rejected_elements_index.delete_at(0)
+
+            rejected_elements.delete_at(0)
+
+          end
+
+        end
+
+      else
+
+        joined_file_contents = input_file_contents.join
+
+      end
+
+      file_id = open(temporary_nila_file, 'w')
+
+      file_id.write(joined_file_contents)
+
+      file_id.close()
+
+      line_by_line_contents = read_file_line_by_line(temporary_nila_file)
+
+      return line_by_line_contents
+
+    end
+
     def compile_loop_keyword(input_file_contents,temporary_nila_file)
 
       def convert_string_to_array(input_string, temporary_nila_file)
@@ -3049,12 +3468,16 @@ def compile(input_file_path, *output_file_name)
 
     file_contents = compile_ternary_if(input_file_contents)
 
+    puts file_contents
+
     file_contents, rejected_lines = ignore_statement_modifiers(file_contents)
 
     file_contents = replace_unless_until(file_contents)
 
     file_contents = compile_regular_if(file_contents, temporary_nila_file)
 
+    file_contents = compile_regular_for(file_contents, temporary_nila_file)
+
     file_contents = compile_regular_while(file_contents, temporary_nila_file)
 
     file_contents = compile_loop_keyword(file_contents,temporary_nila_file)
@@ -3081,7 +3504,7 @@ def compile(input_file_path, *output_file_name)
 
       end
 
-      def extract_variable_names(input_file_contents, temporary_nila_file)
+      def extract_variable_names(input_file_contents)
 
         variables = []
 
@@ -3167,9 +3590,9 @@ def compile(input_file_path, *output_file_name)
 
           file_extract = input_file_contents[0..index_counter]
 
-          file_variables = extract_variable_names(file_extract,temporary_nila_file)
+          file_variables = extract_variable_names(file_extract)
 
-          block_variables = extract_variable_names(loop_extract,temporary_nila_file)
+          block_variables = extract_variable_names(loop_extract)
 
           var_need_of_declaration = file_variables-block_variables-["_i","_j"]
 
@@ -3985,10 +4408,6 @@ def compile(input_file_path, *output_file_name)
 
     file_contents = compile_conditional_structures(file_contents, temp_file)
 
-    file_contents = compile_arrays(file_contents, temp_file)
-
-    file_contents = compile_strings(file_contents)
-
     file_contents = compile_integers(file_contents)
 
     file_contents = compile_default_values(file_contents, temp_file)
@@ -3999,12 +4418,18 @@ def compile(input_file_path, *output_file_name)
 
     file_contents = compile_parallel_assignment(file_contents, temp_file)
 
+    file_contents = compile_arrays(file_contents, temp_file)
+
+    file_contents = compile_strings(file_contents)
+
     file_contents, function_names = compile_named_functions(file_contents, named_functions, nested_functions, temp_file)
 
     list_of_variables, file_contents = get_variables(file_contents, temp_file,loop_vars)
 
     file_contents, ruby_functions = compile_custom_function_map(file_contents)
 
+    #compile_ruby_methods(file_contents)
+
     function_names << ruby_functions
 
     list_of_variables += loop_vars
@@ -4087,7 +4512,7 @@ def find_file_path(input_path, file_extension)
 
 end
 
-nilac_version = "0.0.4.3.0"
+nilac_version = "0.0.4.3.3"
 
 opts = Slop.parse do
   on :c, :compile=, 'Compile Nila File', as:Array, delimiter:":"

metadata

@@ -1,46 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: nilac
 version: !ruby/object:Gem::Version
-  version: 0.0.4.3.0
-  prerelease: 
+  version: 0.0.4.3.3
 platform: ruby
 authors:
 - Adhithya Rajasekaran
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-15 00:00:00.000000000 Z
+date: 2013-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: shark
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: slop
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: Nilac is the official compiler of Nila language
@@ -73,6 +68,7 @@ files:
 - shark/features/multiline_array.feature
 - shark/features/multiple_variable_initialization.feature
 - shark/features/numbers.feature
+- shark/features/regular_for.feature
 - shark/features/regular_if.feature
 - shark/features/regular_while.feature
 - shark/features/ruby_operators.feature
@@ -84,6 +80,7 @@ files:
 - shark/test_files/array_string_indexing.nila
 - shark/test_files/correct.js
 - shark/test_files/correct_default_parameters.js
+- shark/test_files/correct_for.js
 - shark/test_files/correct_hashes.js
 - shark/test_files/correct_heredoc.js
 - shark/test_files/correct_if_then_else.js
@@ -116,6 +113,7 @@ files:
 - shark/test_files/numbers.nila
 - shark/test_files/operators.nila
 - shark/test_files/perfect.js
+- shark/test_files/regular_for.nila
 - shark/test_files/regular_if.nila
 - shark/test_files/regular_while.nila
 - shark/test_files/simple.nila
@@ -128,26 +126,26 @@ files:
 - src/nilac.rb
 homepage: http://adhithyan15.github.com/nila
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.0.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Nilac compiles Nila files into line for line Javascript.
 test_files: []
+has_rdoc: