nilac 0.0.4.3.9.7.1 → 0.0.4.3.9.8

data/lib/nilac/add_line_numbers.rb

@@ -0,0 +1,17 @@
+def add_line_numbers(input_file_contents)
+
+  line_counter = 1
+
+  modified_file_contents = []
+
+  input_file_contents.each do |element|
+
+    modified_file_contents << "<<<#{line_counter}>>> " + element
+
+    line_counter += 1
+
+  end
+
+  return modified_file_contents
+
+end

data/lib/nilac/add_semicolons.rb

@@ -2,11 +2,11 @@
 
     def comment(input_string)
 
-      if input_string.include?("--single_line_comment")
+      if input_string.strip.split("--single_line_comment")[0].eql?("")
 
         true
 
-      elsif input_string.include?("--multiline_comment")
+      elsif input_string.strip.split("--multiline_comment")[0].eql?("")
 
         true
 
@@ -38,7 +38,17 @@
 
                 if line.rstrip[-1] != "[" and line.rstrip[-1] != "{" and line.rstrip[-1] != "," and line.rstrip[-1] != ";"
 
-                  modified_file_contents[index] = line.rstrip + ";\n\n"
+                  line,comment = line.split("--single_line_comment")
+
+                  unless comment.nil? or comment.strip == ""
+
+                    modified_file_contents[index] = line.rstrip + "; --single_line_comment#{comment}\n\n"
+
+                  else
+
+                    modified_file_contents[index] = line.rstrip + ";\n\n"
+
+                  end
 
                 end
 

data/lib/nilac/compile_arrays.rb

@@ -1,8 +1,7 @@
 require_relative 'find_all_matching_indices'
-
 require_relative 'read_file_line_by_line'
-
 require_relative 'compile_interpolated_strings'
+require_relative 'replace_strings'
 
   def compile_arrays(input_file_contents, named_functions, temporary_nila_file)
 
@@ -40,9 +39,19 @@ require_relative 'compile_interpolated_strings'
 
       input_file_contents.each_with_index do |line, index|
 
-        if line.include?("%w{")
+        if line.include?("%w")
+
+          start_delimiter = close_delimiter = line[line.index("%w")+2]
+
+          close_delimiter = "}" if start_delimiter.eql?("{")
+
+          close_delimiter = ")" if start_delimiter.eql?("(")
+
+          close_delimiter = ">" if start_delimiter.eql?("<")
 
-          string_arrays = extract(line, "%w{", "}")
+          close_delimiter = "]" if start_delimiter.eql?("[")
+
+          string_arrays = extract(line, "%w#{start_delimiter}", "#{close_delimiter}")
 
           string_arrays.each do |array|
 
@@ -148,6 +157,8 @@ require_relative 'compile_interpolated_strings'
 
       triple_range_indexes = triple_range_indexes.flatten
 
+      triple_range_indexes = triple_range_indexes.uniq
+
       triple_range_indexing.each_with_index do |line, index|
 
         split1, split2 = line.split("[")
@@ -187,6 +198,8 @@ require_relative 'compile_interpolated_strings'
       end
 
       double_range_indexes = double_range_indexes.flatten
+
+      double_range_indexes = double_range_indexes.uniq
       
       double_range_indexing.each_with_index do |line, index|
 
@@ -214,7 +227,7 @@ require_relative 'compile_interpolated_strings'
 
         else
 
-          replacement_string = split1 + ".slice(#{index_start},#{index_end}+1)\n"
+          replacement_string = split1 + ".slice(#{index_start},#{(index_end.to_i+1).to_s})\n"
 
         end
 
@@ -248,6 +261,24 @@ require_relative 'compile_interpolated_strings'
 
     end
 
+    def compile_array_slicing(input_file_contents)
+
+      possible_slicing_operation = input_file_contents.reject {|element| !replace_strings(element).include?(".slice")}
+
+      possible_slicing_operation.each do |element|
+
+        if replace_strings(element).include?(",last")
+
+          input_file_contents[input_file_contents.index(element)] = input_file_contents[input_file_contents.index(element)].gsub(",last","")
+
+        end
+
+      end
+
+      return input_file_contents
+
+    end
+
     def compile_multiline(input_file_contents, temporary_nila_file)
 
       possible_arrays = input_file_contents.reject { |element| !element.include?("[") }
@@ -324,6 +355,8 @@ require_relative 'compile_interpolated_strings'
 
     input_file_contents = compile_array_indexing(input_file_contents)
 
+    input_file_contents = compile_array_slicing(input_file_contents)
+
     input_file_contents = compile_multiline(input_file_contents, temporary_nila_file)
 
     input_file_contents = compile_array_operators(input_file_contents)

data/lib/nilac/compile_blocks.rb

@@ -1,6 +1,8 @@
 require_relative 'read_file_line_by_line'
 require_relative 'strToArray'
 require_relative 'lexical_scoped_function_variables'
+require_relative 'rollblocks'
+require_relative 'replace_strings'
   
   def compile_blocks(input_file_contents,temporary_nila_file)
 
@@ -24,49 +26,69 @@ require_relative 'lexical_scoped_function_variables'
 
     input_file_contents = input_file_contents.collect {|element| element.gsub(" do"," do ").gsub("do "," do ")}
 
-    possible_blocks = input_file_contents.reject {|line| !line.include?(" do ")}
+    modified_file_contents = input_file_contents.clone.collect {|element| element.gsub("end","end"+"   "*rand(1..10))}
 
-    unless possible_blocks.empty?
+    possible_blocks = modified_file_contents.clone.reject {|line| !line.include?(" do ")}
 
-      possible_blocks.each do |starting_line|
+    extract_expr = /(if |Euuf |while |for |def | do )/
 
-        index_counter = starting_counter = input_file_contents.index(starting_line)
+    starting_locations = []
 
-        line = starting_line
+    input_file_contents.each_with_index do |line, index|
 
-        until line.strip.eql?("end") or line.strip.eql?("end)")
+      if replace_strings(line).index(extract_expr) != nil
 
-          index_counter += 1
+        starting_locations << index
 
-          line = input_file_contents[index_counter]
+      end
 
-        end
+    end
+
+    starting_locations = [0,starting_locations,-1].flatten.uniq
+
+    remaining_contents, extracted_blocks = extract_blocks(starting_locations,modified_file_contents,["if","for","while","def and do"])
+
+    possible_blocks = extracted_blocks.reject {|element| !element[0].index(/( do )/)}
+
+    replaced_blocks = []
+
+    unless possible_blocks.empty?
+
+      possible_blocks.each do |element|
 
-        loop_extract = input_file_contents[starting_counter..index_counter]
+        starting_counter = modified_file_contents.index(element[0])
 
-        loop_condition, block = loop_extract.join.split(" do ")
+        end_counter = modified_file_contents.index(element[-1])
 
-        block = block.split("end")[0]
+        loop_extract = input_file_contents[starting_counter..end_counter]
 
-        replacement_string = "#{loop_condition.rstrip} blockky {#{block.strip}}_!"
+        loop_condition,function_parameters= loop_extract[0].split(" do ")
 
-        input_file_contents[starting_counter..index_counter] = replacement_string
+        block = [function_parameters] + loop_extract[1...-1]
+
+        replacement_string = "#{loop_condition.rstrip} blockky \n{#{block.join.strip}\n}_!"
+
+        replaced_blocks << replacement_string
+
+        input_file_contents[starting_counter..end_counter] = replacement_string
+
+        modified_file_contents[starting_counter..end_counter] = replacement_string
 
       end
 
     end
 
-    possible_blocks = input_file_contents.reject{ |element| !element.include?(" blockky ")}
+    original_blocks = replaced_blocks.clone
 
-    possible_blocks = possible_blocks.reject {|element| !element.include?("{") and !element.include?("}")}
+    possible_blocks = replaced_blocks.clone
 
-    modified_file_contents = input_file_contents.clone
+    joined_file_contents = input_file_contents.clone.join
 
     unless possible_blocks.empty?
 
-      possible_blocks.each do |loop|
+      possible_blocks.each_with_index do |loop,index|
 
-        original_loop = loop.clone
+        original_loop = original_blocks[index]
 
         string_counter = 1
 
@@ -84,7 +106,7 @@ require_relative 'lexical_scoped_function_variables'
 
         end
 
-        block_extract = loop[loop.index("{")..loop.index("}_!")]
+        block_extract = strToArray(loop)[1..-1].join[0...-2]
 
         compiled_block = ""
 
@@ -154,24 +176,64 @@ require_relative 'lexical_scoped_function_variables'
 
         end
 
-        replacement_array[1...-1] = replacement_array[1...-1].collect {|element| "#iggggnnnore #{element}"}
+        replacement_array[1...-1] = replacement_array[1...-1].collect do |element|
+
+          if element.include?("#iggggnnnore")
+
+            element
+
+          else
+
+            "#iggggnnnore #{element}"
+
+          end
+
+        end
+
+        starting_counter = joined_file_contents.index(original_loop)
+
+        if starting_counter.nil?
+
+          starting_counter = joined_file_contents.index(original_loop.lstrip)
+
+        end
+
+        end_counter = starting_counter+original_loop.length
+
+        joined_file_contents[starting_counter..end_counter] = replacement_array.join
+
+        nested_blocks = possible_blocks.clone.reject {|element| !element.include?(original_loop)}
 
-        modified_file_contents[input_file_contents.index(original_loop)] = replacement_array.join
+        nested_blocks = nested_blocks.reject {|element| element.eql?(original_loop)}
+
+        nested_blocks.each do |block|
+
+          replacement_block = original_blocks[original_blocks.index(block)]
+
+          starting_counter = replacement_block.index(original_loop)
+
+          end_counter = replacement_block.index(original_loop)+original_loop.length
+
+          replacement_block[starting_counter..end_counter] = replacement_array.join
+
+          original_blocks[original_blocks.index(block)] = replacement_block
+
+        end
 
       end
 
     end
 
-    modified_file_contents = modified_file_contents.collect {|element| element.gsub("appand","append")}
-
     file_id = open(temporary_nila_file, 'w')
 
-    file_id.write(modified_file_contents.join)
+    file_id.write(joined_file_contents)
 
     file_id.close()
 
     line_by_line_contents = read_file_line_by_line(temporary_nila_file)
 
+    line_by_line_contents = line_by_line_contents.collect {|element| element.gsub("appand","append")}
+
     return line_by_line_contents
 
   end

data/lib/nilac/compile_case_statement.rb

@@ -51,6 +51,10 @@ require_relative 'read_file_line_by_line'
 
     possible_case_statements = input_file_contents.reject {|element| !element.include?("case ")}
 
+    possible_case_statements = possible_case_statements.reject {|element| replace_strings(element).include?(".downcase")}
+
+    possible_case_statements = possible_case_statements.reject {|element| replace_strings(element).include?(".upcase")}
+
     case_statements = []
 
     possible_case_statements.each do |statement|

data/lib/nilac/compile_chained_comparison.rb

@@ -0,0 +1,35 @@
+require_relative 'replace_strings'
+
+def compile_chained_comparison(input_file_contents)
+
+  select_regex = /\s?(=?[><]=?|==[=]?|&&|\|\|)/
+
+  modified_file_contents = input_file_contents.collect {|element| replace_strings(element)}
+
+  possible_comparisons = modified_file_contents.reject {|element| !element.index(select_regex)}
+
+  possible_comparisons.each do |comparison|
+
+    original_expression = comparison.dup
+
+    comparison_split = comparison.split
+
+    comparison_op_locations = comparison_split.each_index.select {|index| comparison_split[index].index(select_regex)}
+
+    compared_expressions = []
+
+    if comparison_op_locations.length > 1
+
+      comparison_op_locations.each do |op_index|
+
+        compared_expressions << [comparison_split[op_index-1],comparison_split[op_index], comparison_split[op_index+1]]
+
+      end
+
+    end
+
+
+
+  end
+
+end

data/lib/nilac/compile_comments.rb

@@ -1,4 +1,5 @@
 require_relative 'read_file_line_by_line'
+require_relative 'strToArray'
   
   def compile_comments(input_file_contents, comments, temporary_nila_file)
 
@@ -50,6 +51,14 @@ require_relative 'read_file_line_by_line'
 
       replacement_multiline_string = replacement_multiline_string.sub("=end", "\n*/")
 
+      replacement_array = strToArray(replacement_multiline_string)
+
+      replacement_array[2...-2] = replacement_array[2...-2].collect {|element| "  " + element}
+
+      replacement_array = [replacement_array[0]] + replacement_array[1...-1].reject {|element| element.strip.eql?("")} + [replacement_array[-1]]
+
+      replacement_multiline_string = replacement_array.join
+
       ignorable_keywords.each_with_index do |keyword, index|
 
         if replacement_multiline_string.index(keyword) != nil

data/lib/nilac/compile_conditional_structures.rb

@@ -1,4 +1,5 @@
 require_relative 'read_file_line_by_line'
+require_relative 'replace_strings'
 
 def compile_conditional_structures(input_file_contents, temporary_nila_file)
 
@@ -84,10 +85,20 @@ def compile_conditional_structures(input_file_contents, temporary_nila_file)
 
       matching_lines.each do |line|
 
+        line,comment = line.split("--single_line_comment")
+
+        comment ||= ""
+
         line_split = line.split(plain_conditionals[index])
 
         condition = line_split[1]
 
+        if replace_strings(condition).include?("not")
+
+          condition = condition.gsub(/not\s*/,"!")
+
+        end
+
         condition = condition.gsub(" and "," && ").gsub(" or "," || ").gsub(" not "," !")
 
         if index == 0
@@ -150,7 +161,7 @@ def compile_conditional_structures(input_file_contents, temporary_nila_file)
 
       extracted_blocks = []
 
-      controlregexp = /(if |while |def | do )/
+      controlregexp = /(if |while |def | do |for )/
 
       rejectionregexp = /( if | while )/
 
@@ -347,7 +358,7 @@ def compile_conditional_structures(input_file_contents, temporary_nila_file)
 
       if_statement_indexes = [0] + if_statement_indexes.flatten + [-1]
 
-      controlregexp = /(while |def | do )/
+      controlregexp = /(while |def | do |for)/
 
       modified_input_contents, extracted_statements = extract_if_blocks(if_statement_indexes, input_file_contents.clone)
 
@@ -923,7 +934,7 @@ def compile_conditional_structures(input_file_contents, temporary_nila_file)
 
     input_file_contents = input_file_contents.collect {|element| element.gsub("forEach","fuuuuurEEEEEach")}
 
-    possible_for_statements = input_file_contents.reject { |element| !element.include?("for") }
+    possible_for_statements = input_file_contents.reject { |element| !replace_strings(element).include?("for") }
 
     possible_for_statements = possible_for_statements.reject {|element| element.include?("for (")}
 
@@ -1195,10 +1206,20 @@ def compile_conditional_structures(input_file_contents, temporary_nila_file)
 
       return modified_input_block
 
+    end
+
+    def compile_inline_loop(input_loop)
+
+
+
     end
 
     possible_loop_statements = input_file_contents.reject { |element| !element.include?("loop") }
 
+    inline_loops = possible_loop_statements.reject{|element| element.include?("do")}
+
+    possible_loop_statements = possible_loop_statements - inline_loops
+
     if !possible_loop_statements.empty?
 
       loop_statement_indexes = []
@@ -1211,6 +1232,8 @@ def compile_conditional_structures(input_file_contents, temporary_nila_file)
 
       loop_statement_indexes = [0] + loop_statement_indexes.flatten + [-1]
 
+      loop_statement_indexes = loop_statement_indexes.uniq
+
       controlregexp = /(if |def )/
 
       modified_input_contents, extracted_statements = extract_loop_blocks(loop_statement_indexes, input_file_contents.clone)