frepl 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9b623779b0cd2543b859da5e7b63195c7e54f6e8
+  data.tar.gz: fde5b1a7e38e9ef4b8f1a2a1897dd875fef2de71
+SHA512:
+  metadata.gz: c532180ba00cd864128c61d421a9fa9328eb86490c74a3554377583b11535e1542bf0e1f73bb1956b82b8d8ce4b7c820fb2fccba2f5b676957cbc876fae4d965
+  data.tar.gz: 8b0af0047ebd2691dae341d4dd57944800062e0a44e096f4f6d0a33e5db5190202f5b03624da4749f838244c6643b9f055f66b1c57cde9e321982d1e54108fcf

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.f90
+frepl_out

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in frepl.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Luke Rodgers
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,120 @@
+# Frepl
+
+Frepl (Fortran REPL) is an experimental ruby-based REPL for Fortran,
+that I wrote because I was trying to learn Fortran, and I find the feedback
+loop you get with a REPL makes learning a language much easier and more
+enjoyable.
+
+You don't need to know ruby to use Frepl, but you do need to have ruby (at least version 2)
+installed.
+
+There are a lot of deficiencies with this code, namely:
+
+* Only knows how to classify/parse a limited set of Fortran.
+* IO is severely hampered; basically you can't do the I part.
+I have some ideas about how to sort of accomplish this but
+they are half-baked and convoluted. Also I'm not sure this is
+even really that important.
+* Parsing is pretty dumb. It uses complicated and somewhat opaque regexes in places
+where a real lexer/parser approach might be more appropriate, though might also be
+overkill.
+
+## Project plans
+
+See issue tracker.
+
+## Known issues
+
+* Frepl is only able to correctly classify a subset of legal Fortran. At the same time,
+Frepl will also happily accept some illegal Fortran, and wait for the compiler to tell you
+about the problem. The UX here is not great.
+* When specifying parameter and dimension in a declaration, parameter must currently come first,
+e.g. `integer, parameter, dimension(:) :: a`.
+* only `do... end do` loops are supported
+* no support for labels; hence, no GOTO and its ilk
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'frepl'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install frepl
+
+## Usage
+
+You should be able to run `frepl` from the command line after having installed the gem.
+
+Alternatively, if you have the source code, you can run `rake console` from the gem folder.
+
+You will get a prompt, and you can just start typing Fortran, type `q` to quit.
+
+```
+> integer :: a = 1
+> integer, dimension(:), allocatable :: b
+> allocate(b(0:4))
+> b = [1,2,3,4]
+> write(*,*) a * b
+           1           2           3           4
+> q
+```
+
+### Redefine a function, change the type of a variable, etc.
+
+```
+> integer :: a = 1
+> a = 3
+           3
+> real a
+> a = 5
+   5.00000000
+> integer function sum(a, b)
+>   integer, intent(in) :: a, b
+>   sum = a + b
+>   end function
+> write(*,*) sum(1,2)
+           3
+> real function sum(a, b, c)
+>   real, intent(in) :: a, b, c
+>   sum = a + b + c
+>   end function
+> write(*,*) sum(1.0,2.9,3.4)
+   7.30000019
+>
+```
+
+### Undo the last statement
+
+Type `f:z` (z as in cmd+z for undo). Handy when you made an error, e.g.
+
+```
+> integer :: a =3
+> real :: b
+> b = 'fo'
+frepl_out.f90:5.4:
+
+b = 'fo'
+    1
+Error: Can't convert CHARACTER(1) to REAL(4) at (1)
+
+> f:z
+> b = 3.4
+   3.40000010
+>
+```
+
+You can see some repl commands by typing `f:help`. Not much going on there, currently.
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/frepl/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,15 @@
+require "bundler/gem_tasks"
+require 'frepl'
+
+task :console do
+  require 'pry'
+  require 'frepl'
+
+  def reload!
+    files = $LOADED_FEATURES.select { |feat| feat =~ /\/frepl\// }
+    files.each { |file| load file }
+  end
+
+  ARGV.clear
+  Pry.start
+end

data/bin/frepl

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'frepl'
+
+Frepl::Main.run

data/frepl.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'frepl/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "frepl"
+  spec.version       = Frepl::VERSION
+  spec.authors       = ["Luke Rodgers"]
+  spec.email         = ["lukeasrodgers@gmail.com"]
+  spec.summary       = %q{A hacky, experimental Fortran REPL in ruby}
+  spec.description   = %q{(Badly) supports a small subset of Fortran to be run in a REPL-like environment, with a bunch of caveats.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'activesupport', '> 4'
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rspec", "~> 3.3"
+  spec.add_development_dependency "rspec-mocks", "~> 3.3"
+  spec.add_development_dependency "byebug"
+end

data/lib/frepl.rb

@@ -0,0 +1,81 @@
+require 'readline'
+require 'frepl/version'
+require 'frepl/classifier'
+require 'frepl/statement'
+require 'frepl/fortran_file'
+
+module Frepl
+  extend self
+
+  attr_accessor :compiler, :debug
+
+  def log(message)
+    puts message if @debug
+  end
+
+  def output(o)
+    puts o
+  end
+
+  class Main
+    class << self
+      def run
+        new.run
+      end
+    end
+
+    def initialize
+      Frepl.compiler = 'gfortran'
+      Frepl.debug = false
+      reset!
+    end
+
+    def run
+      loop do
+        begin
+          while buf = Readline.readline(prompt, true)
+            @lines << buf
+            process_line(buf)
+          end
+        rescue Interrupt
+          @classifier.interrupt
+          puts "^C\n"
+        rescue SystemExit, SignalException
+          raise
+        rescue Exception => e
+          puts "Exception!: #{e}"
+          puts e.backtrace
+          raise
+        end
+      end
+    end
+    
+    def run_file(file)
+      file.each do |line|
+        @lines << line
+        process_line(line)
+      end
+      reset!
+    end
+
+    private
+
+    def prompt
+       '> ' + (' ' * @classifier.indentation_level)
+    end
+
+    def process_line(line)
+      exit(0) if line.chomp == 'q'
+      Frepl.log("classifying: #{line}")
+      line_obj = @classifier.classify(line)
+      @file.add(line_obj) unless line_obj.nil? || line_obj.incomplete?
+    end
+
+    def reset!
+      @classifier = Classifier.new
+      @file = FortranFile.new
+      @lines = []
+    end
+  end
+
+end

data/lib/frepl/classifier.rb

@@ -0,0 +1,190 @@
+module Frepl
+  class Classifier
+    VARIABLE_NAME_REGEX = /[a-zA-Z][a-zA-Z0-9_]{,30}/
+    # TODO this regex seems incorrect, e.g. assignable value can't start with most punctuation
+    ASSIGNABLE_VALUE_REGEX = /[^\s]+/
+    DERIVED_TYPE_IDENTIFIER_REGEX = /\(#{VARIABLE_NAME_REGEX}\)/
+    DERIVED_TYPE_REGEX = /type\s+(#{VARIABLE_NAME_REGEX})/i
+    BUILTIN_TYPE_REGEX = /real|integer|character|logical/i
+    DECLARABLE_TYPE_REGEX = /#{BUILTIN_TYPE_REGEX}|type\s\(#{VARIABLE_NAME_REGEX}\)\s/i
+    # TODO: parameter/dimension order shouldn't matter here
+    DECLARATION_REGEX = /\As*(#{DECLARABLE_TYPE_REGEX})\s*(\((?:kind=|len=)*[^\(\)]+\)){,1}+(\s*,?\s*parameter\s*,?\s*)?(\s*,?\s*dimension\([^\)]+\))?(\s*,?\s*target)?(\s*,?\s*pointer)?\s*(?:::)?\s*([^(?:::)]*)/
+    ASSIGNABLE_REGEX = /#{VARIABLE_NAME_REGEX}|#{VARIABLE_NAME_REGEX}%#{VARIABLE_NAME_REGEX}/
+    ASSIGNMENT_REGEX = /\As*(#{ASSIGNABLE_REGEX})\s*=\s*(#{ASSIGNABLE_VALUE_REGEX})/
+    OLDSKOOL_ARRAY_VALUE_REGEX = /\/[^\]]+\//
+    F2003_ARRAY_VALUE_REGEX = /\[[^\]]+\]/
+    ARRAY_VALUE_REGEX = /#{OLDSKOOL_ARRAY_VALUE_REGEX}|#{F2003_ARRAY_VALUE_REGEX}/
+    FUNCTION_REGEX = /(#{BUILTIN_TYPE_REGEX})\s+function\s+(#{VARIABLE_NAME_REGEX})/i
+    SUBROUTINE_REGEX = /subroutine\s+(#{VARIABLE_NAME_REGEX})/i
+    IF_STATEMENT_REGEX = /if\s+\(.+\)\sthen/i
+    DO_LOOP_REGEX = /do\s+[^,]+,.+/i
+    WHERE_REGEX = /where\s+\([^\)]+\)\s*/i
+
+    def initialize
+      @all_lines = []
+      @current_lines = []
+      @current_multiline_obj = nil
+    end
+
+    def classify(line)
+      if @current_multiline_obj && !@current_multiline_obj.incomplete?
+        @current_multiline_obj = nil
+        @current_lines = []
+      end
+
+      @all_lines << line
+      @current_lines << line
+
+      if multiline?(line)
+        Frepl.log("MULTILINE")
+        classify_multiline(line)
+        return @current_multiline_obj
+      else
+        return classify_single_line(line)
+      end
+    end
+
+    def interrupt
+      @current_multiline_obj = nil
+      @current_lines = []
+    end
+
+    def executable?
+      !get_more_lines?
+    end
+
+    def lines_to_execute
+      @current_lines
+    end
+
+    def multiline?(line)
+      line.match(/\Asubroutine|function|(?:#{IF_STATEMENT_REGEX})|(?:#{DO_LOOP_REGEX})|(?:#{DERIVED_TYPE_REGEX})|(?:#{WHERE_REGEX})\z/i) || @current_multiline_obj != nil
+    end
+
+    def repl_command?
+      current_line.start_with?('f:')
+    end
+
+    # TODO this is stupid, may need real parser here
+    def multi_declaration?
+      m = current_line.match(DECLARATION_REGEX)
+      return false unless m
+      if m[7].gsub(ARRAY_VALUE_REGEX, '').count(',') > 0
+        true
+      else
+        false
+      end
+    end
+
+    # TODO this is stupid, may need real parser here
+    def declaration?
+      m = current_line.match(DECLARATION_REGEX)
+      return false unless m
+      if m[7].gsub(ARRAY_VALUE_REGEX, '').count(',') == 0
+        true
+      else
+        false
+      end
+    end
+
+    def allocation?
+      current_line.match(/allocate\(/) != nil
+    end
+
+    def run?
+      current_line.match(/\s*write|print|read|call/i) != nil
+    end
+
+    def assignment?
+      current_line.match(ASSIGNMENT_REGEX)
+    end
+
+    def standalone_variable?
+      current_line.match(/\A#{VARIABLE_NAME_REGEX}\z/)
+    end
+
+    def indentation_level
+      if @current_multiline_obj && @current_multiline_obj.incomplete?
+        2
+      else
+        0
+      end
+    end
+
+    private
+
+    def classify_multiline(line)
+      if @current_lines.size == 1
+        raise 'Already have multiline obj' unless @current_multiline_obj.nil?
+        if line.match(/function/)
+          @current_multiline_obj = Function.new
+        elsif line.match(/subroutine/)
+          @current_multiline_obj = Subroutine.new
+        elsif line.match(IF_STATEMENT_REGEX)
+          @current_multiline_obj = IfStatement.new
+        elsif line.match(DO_LOOP_REGEX)
+          @current_multiline_obj = DoLoop.new
+        elsif line.match(/\A#{DERIVED_TYPE_REGEX}\z/)
+          @current_multiline_obj = DerivedType.new
+        elsif line.match(/\A#{WHERE_REGEX}\z/)
+          @current_multiline_obj = Where.new
+        end
+      end
+      @current_multiline_obj.lines << line
+    end
+
+    def classify_single_line(line)
+      obj = if repl_command?
+        ReplCommand.new(line)
+      elsif multi_declaration?
+        MultiDeclaration.new(line)
+      elsif declaration?
+        Declaration.new(line)
+      elsif run?
+        Execution.new(line)
+      elsif assignment?
+        Assignment.new(line)
+      elsif allocation?
+        Allocation.new(line)
+      elsif standalone_variable?
+        StandaloneVariable.new(line)
+      elsif ignorable?
+        nil
+      else
+        puts "I don't think `#{line}` is valid Fortran. You made a mistake, or, more likely, I'm dumb."
+        @all_lines.pop
+        obj = nil
+      end
+      @current_lines = []
+      obj
+    end
+
+    def current_line
+      @current_lines.last
+    end
+
+    def get_more_lines?
+      @current_lines.size > 0 || @current_lines.last.match(/subroutine|function/)
+    end
+
+    def done_multiline?
+      @current_lines.size > 0 && @current_lines.last.match(/end subroutine|end function/)
+    end
+
+    def ignorable?
+      program_statements? || blank? || comment?
+    end
+
+    def program_statements?
+      current_line.match(/\Aprogram .+|implicit .+|\Aend program/) != nil
+    end
+
+    def blank?
+      current_line.match(/\A\s*\z/)
+    end
+
+    def comment?
+      current_line.match(/\A!/)
+    end
+  end
+end