frepl 0.0.1

data/lib/frepl/fortran_file.rb

@@ -0,0 +1,159 @@
+require 'active_support/core_ext/string'
+
+module Frepl
+  class FortranFile
+    BEGIN_PROGRAM_STATEMENT = "program frepl_out\n"
+    END_PROGRAM_STATEMENT = "end program frepl_out\n"
+    FUNC_SUBROUTINE_HEADER = "  contains\n"
+    IMPLICIT_STATEMENT = "  implicit none\n"
+
+    def initialize
+      @all_statements = []
+      @declarations = []
+      @derived_types = []
+      @assignments = []
+      @execution = nil
+      @allocations = []
+      @subroutines = []
+      @functions = []
+      @wheres = []
+    end
+
+    def run
+      File.open('frepl_out.f90', 'w+') do |f|
+        f << BEGIN_PROGRAM_STATEMENT
+        f << IMPLICIT_STATEMENT
+
+        @derived_types.each do |dt|
+          f.write(dt.output)
+        end
+
+        @declarations.each do |d|
+          f.write(d.output)
+        end
+
+        @allocations.each do |a|
+          f.write(a.output)
+        end
+
+        @assignments.each do |a|
+          f.write(a.output)
+        end
+
+        if @execution
+          f.write(@execution.output)
+        end
+
+        if @subroutines.any? || @functions.any?
+          f << FUNC_SUBROUTINE_HEADER
+
+          @subroutines.each do |sub|
+            f.write(sub.output)
+          end
+
+          @functions.each do |fn|
+            f.write(fn.output)
+          end
+        end
+
+        f << END_PROGRAM_STATEMENT
+      end
+      o = `#{Frepl.compiler} frepl_out.f90 -o frepl_out && ./frepl_out`
+      Frepl.output(o)
+    end
+
+    def add(line_obj)
+      line_obj.accept(self)
+      @all_statements << line_obj
+      Frepl.log("added")
+      Frepl.log("declarations: #{@declarations}")
+      Frepl.log("assignments: #{@assignments}")
+    end
+
+    def undo_last!
+      last_statement = @all_statements.last
+      ivar = instance_variable_get("@#{last_statement.class.to_s.demodulize.underscore.pluralize}")
+      ivar.pop
+    end
+
+    def visit_declaration(declaration)
+      if i = @declarations.find_index { |d| d == declaration }
+        @declarations[i] = declaration
+        if j = @assignments.find_index { |a| a.variable_name == declaration.variable_name }
+          @assignments.slice!(j)
+        end
+      else
+        @declarations << declaration
+      end
+    end
+
+    def visit_multi_declaration(multi_declaration)
+      multi_declaration.declarations.each do |d|
+        visit_declaration(d)
+      end
+    end
+
+    def visit_assignment(a)
+      @assignments << a
+      e = Execution.new(a.expressionize)
+      visit_execution(e)
+      Frepl.log("assignment name: #{a.variable_name}")
+    end
+
+    def visit_standalone_variable(sv)
+      e = Execution.new(sv.expressionize)
+      visit_execution(e)
+    end
+
+    def visit_allocation(a)
+      @allocations << a
+    end
+
+    def visit_execution(e)
+      @execution = e
+      run
+    end
+
+    def visit_repl_command(cmd)
+      cmd.run(self)
+    end
+
+    def visit_function(fn)
+      if i = @functions.find_index { |f| f == fn }
+        @functions[i] = fn
+      else
+        @functions << fn
+      end
+    end
+
+    def visit_subroutine(sub)
+      if i = @subroutines.find_index { |s| s == sub }
+        @subroutines[i] = sub
+      else
+        @subroutines << sub
+      end
+    end
+
+    def visit_ifstatement(i)
+      e = Execution.new(i.output)
+      visit_execution(e)
+    end
+
+    def visit_do_loop(d)
+      e = Execution.new(d.output)
+      visit_execution(e)
+    end
+
+    def visit_where(w)
+      @assignments << w
+    end
+
+    def visit_derived_type(dt)
+      if i = @derived_types.find_index { |v| v == dt }
+        @derived_types[i] = dt
+      else
+        @derived_types << dt
+      end
+    end
+  end
+end

data/lib/frepl/statement.rb

@@ -0,0 +1,93 @@
+module Frepl
+  class Statement
+    def incomplete?
+      raise NotImplementedError
+    end
+
+    def output
+      raise NotImplementedError
+    end
+
+    def accept
+      raise NotImplementedError
+    end
+
+    # def accept(visitor)
+      # method = "visit_#{self.class.name.downcase}".to_sym
+      # visitor.public_send(method, visitor)
+    # end
+  end
+
+  class SinglelineStatement < Statement
+    attr_reader :line
+
+    def initialize(line)
+      @line = line
+      parse
+    end
+
+    def output
+      @line.to_s + "\n"
+    end
+    
+    def incomplete?
+      false
+    end
+
+    private
+
+    def parse
+      # override me at your leisure, to get parsing on initialization
+    end
+  end
+
+  class MultilineStatement < Statement
+    attr_reader :lines
+
+    def initialize(lines = [])
+      @lines = lines
+    end
+
+    def output
+      @lines.join("\n") + "\n"
+    end
+
+    def incomplete?
+      !complete?
+    end
+
+    def complete?
+      @lines.last.match(terminal_regex) != nil && !nested?
+    end
+
+    def terminal_regex
+      raise NotImplementedError
+    end
+
+    private
+
+    def starting_regex
+      raise NotImplementedError
+    end
+
+    def nested?
+      start_count = lines.select { |line| line.match(/\A\s*#{starting_regex}\z/) != nil }.count
+      end_count = lines.select { |line| line.match(/\A\s*#{terminal_regex}\z/) != nil }.count
+      start_count > end_count
+    end
+  end
+end
+
+require 'frepl/statements/function'
+require 'frepl/statements/subroutine'
+require 'frepl/statements/declaration'
+require 'frepl/statements/multi_declaration'
+require 'frepl/statements/allocation'
+require 'frepl/statements/assignment'
+require 'frepl/statements/standalone_variable'
+require 'frepl/statements/execution'
+require 'frepl/statements/repl_command'
+require 'frepl/statements/if_statement'
+require 'frepl/statements/do_loop'
+require 'frepl/statements/derived_type'
+require 'frepl/statements/where'

data/lib/frepl/statements/allocation.rb

@@ -0,0 +1,9 @@
+require 'frepl/statements/declaration'
+
+module Frepl
+  class Allocation < Declaration
+    def accept(visitor)
+      visitor.visit_allocation(self)
+    end
+  end
+end

data/lib/frepl/statements/assignment.rb

@@ -0,0 +1,19 @@
+module Frepl
+  class Assignment < SinglelineStatement
+    def variable_name
+      @variable_name ||= @line.match(Frepl::Classifier::ASSIGNMENT_REGEX)[1]
+    end
+
+    def assigned_value
+      @assigned_value ||= @line.match(Frepl::Classifier::ASSIGNMENT_REGEX)[2]
+    end
+
+    def expressionize
+      "write(*,*) #{variable_name}"
+    end
+
+    def accept(visitor)
+      visitor.visit_assignment(self)
+    end
+  end
+end

data/lib/frepl/statements/declaration.rb

@@ -0,0 +1,47 @@
+module Frepl
+  class Declaration < SinglelineStatement
+    attr_reader :variable_name, :assigned_value, :type, :len, :kind
+
+    def accept(visitor)
+      visitor.visit_declaration(self)
+    end
+
+    def ==(other)
+      if other.is_a?(Declaration)
+        self.variable_name == other.variable_name
+      else
+        super(other)
+      end
+    end
+
+    def target?
+      @target != nil
+    end
+
+    def pointer?
+      @pointer != nil
+    end
+
+    private
+    
+    def parse
+      match_data = line.match(Frepl::Classifier::DECLARATION_REGEX)
+      variable_part = match_data[7]
+      variable_data = variable_part.match(/\s*(#{Frepl::Classifier::VARIABLE_NAME_REGEX})\s*+=*\s*(.*)?/)
+      @variable_name = variable_data[1]
+      kind_len = match_data[2]
+      if kind_len
+        value = kind_len.match(/=?+([^=\(\)(?:kind|len)]+)/)[1]
+        if kind_len.match(/kind/)
+          @kind = value
+        else
+          @len = value
+        end
+      end
+      @assigned_value = variable_data[2].empty? ? nil : variable_data[2]
+      @type = match_data[1]
+      @target = match_data[5]
+      @pointer = match_data[6]
+    end
+  end
+end

data/lib/frepl/statements/derived_type.rb

@@ -0,0 +1,29 @@
+module Frepl
+  class DerivedType < MultilineStatement
+    def terminal_regex
+      /end type\s*#{Frepl::Classifier::VARIABLE_NAME_REGEX}/i
+    end
+
+    def accept(visitor)
+      visitor.visit_derived_type(self)
+    end
+
+    def name
+      @name ||= lines.first.match(Frepl::Classifier::DERIVED_TYPE_REGEX)[1]
+    end
+
+    def ==(other)
+      if other.is_a?(DerivedType)
+        self.name == other.name
+      else
+        super(other)
+      end
+    end
+
+    private
+
+    def starting_regex
+      Frepl::Classifier::DERIVED_TYPE_REGEX
+    end
+  end
+end

data/lib/frepl/statements/do_loop.rb

@@ -0,0 +1,17 @@
+module Frepl
+  class DoLoop < MultilineStatement
+    def terminal_regex
+      /end do/
+    end
+
+    def accept(visitor)
+      visitor.visit_do_loop(self)
+    end
+
+    private
+
+    def starting_regex
+      Frepl::Classifier::DO_LOOP_REGEX
+    end
+  end
+end

data/lib/frepl/statements/execution.rb

@@ -0,0 +1,7 @@
+module Frepl
+  class Execution < SinglelineStatement
+    def accept(visitor)
+      visitor.visit_execution(self)
+    end
+  end
+end

data/lib/frepl/statements/function.rb

@@ -0,0 +1,29 @@
+module Frepl
+  class Function < MultilineStatement
+    def terminal_regex
+      /end function/
+    end
+
+    def accept(visitor)
+      visitor.visit_function(self)
+    end
+
+    def name
+      @name ||= lines.first.match(Frepl::Classifier::FUNCTION_REGEX)[2]
+    end
+
+    def ==(other)
+      if other.is_a?(Function)
+        self.name == other.name
+      else
+        super(other)
+      end
+    end
+    
+    private
+
+    def starting_regex
+      Frepl::Classifier::FUNCTION_REGEX
+    end
+  end
+end

data/lib/frepl/statements/if_statement.rb

@@ -0,0 +1,17 @@
+module Frepl
+  class IfStatement < MultilineStatement
+    def terminal_regex
+      /end\s?if/
+    end
+
+    def accept(visitor)
+      visitor.visit_ifstatement(self)
+    end
+
+    private
+
+    def starting_regex
+      Frepl::Classifier::IF_STATEMENT_REGEX
+    end
+  end
+end

data/lib/frepl/statements/multi_declaration.rb

@@ -0,0 +1,70 @@
+module Frepl
+  class MultiDeclaration < SinglelineStatement
+    attr_reader :variable_names
+
+    def accept(visitor)
+      visitor.visit_multi_declaration(self)
+    end
+
+    def declarations
+      @declarations ||= @variable_parts.map do |varpart|
+        str = "#{@type}"
+        str << "#{@kind_len}" if @kind_len
+        str << "#{@parameter}" if @parameter
+        str << "#{@dimension}" if @dimension
+        str << "#{@target}" if @target
+        str << "#{@pointer}" if @pointer
+        str << " :: #{varpart}"
+        Declaration.new(str)
+      end
+    end
+
+    private 
+
+    # TODO regex needs better parameter/dimension parsing
+    def parse
+      match_data = line.match(Frepl::Classifier::DECLARATION_REGEX)
+      @type = match_data[1]
+      kind_len = match_data[2]
+      if @kind_len
+        if @kind_len.match(/len/)
+          @len = @kind_len.match(/=(\d+)/)[1]
+        else
+          @kind = @kind_len.match(/=(\d+)/)[1]
+        end
+      end
+      @parameter = match_data[3]
+      @dimension = match_data[4]
+      @target = match_data[5]
+      @pointer = match_data[6]
+      @variable_names = match_data[7].gsub(/\s*=\s*/, '=').scan(Frepl::Classifier::VARIABLE_NAME_REGEX)
+      @variable_assignments = match_data[7].gsub(/\s*=\s*/, '=').
+        split(Frepl::Classifier::VARIABLE_NAME_REGEX)[1..-1].
+        map { |a| a.gsub(/,\s*$/, '') }
+      if @variable_assignments && @variable_assignments.any?
+        if @variable_assignments.size < @variable_names.size
+          # e.g., integer :: a = 1, b, c
+          mask = match_data[7].gsub(/\s*=\s*/, '=').
+            scan(/#{Frepl::Classifier::VARIABLE_NAME_REGEX}[=,$\z]?/).
+            map { |x| x.match(/=/) ? '=' : '' }
+          arr = []
+          # pad var assignments array, determine correct locations
+          mask.each do |m|
+            if m == '='
+              arr.push(@variable_assignments.shift)
+            else
+              arr.push('')
+            end
+          end
+          @variable_assignments = arr
+        end
+        # should be something like [['a', 'b'], ['=1', '']]
+        @variable_parts = [@variable_names, @variable_assignments].transpose.map do |variable_parts|
+          variable_parts.join('')
+        end
+      else
+        @variable_parts = @variable_names
+      end
+    end
+  end
+end