fruitloop 0.3

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+== FRUITLOOP
+
+Copyright (c) 2012-2012 Thomas Hoefer
+
+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,33 @@
+FRUITLOOP
+=========
+Implementation of the LOOP programming language which compiles to JavaScript. See: http://de.wikipedia.org/wiki/LOOP-Programm. 
+
+
+DEPENDENCIES
+============
+- Ruby >= 1.9.2p290, not tested with other versions
+- Node.js >= 0.5.6; the binary is expected to be located at /usr/local/bin/node 
+
+
+HOWTO
+=====
+- Run "ruby fruitloop.rb add.loop" to compile and execute "add.loop". The same goes for the other examples. 
+- The result of a computation will always be located in variable "xa". 
+
+
+GRAMMAR
+=======
+- S ::= P$
+- P ::= id A X | loop id do P end X
+- A ::= : B
+- B ::= = C
+- C ::= id D | number
+- D ::= + number | - number
+- X ::= ; P X | Epsilon
+
+
+License
+=======
+FRUITLOOP is released under the MIT license: [www.opensource.org/licenses/MIT](www.opensource.org/licenses/MIT) 
+
+

data/Rakefile

@@ -0,0 +1,30 @@
+# 
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+ 
+
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  files =['README', 'LICENSE', 'lib/**/*.rb']
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README" # page to start on
+  rdoc.title = "LoopLang Docs"
+  rdoc.rdoc_dir = 'doc/rdoc' # rdoc output folder
+  rdoc.options << '--line-numbers'
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*.rb']
+end

data/lib/add.loop

@@ -0,0 +1,6 @@
+xa := 7;
+xb := 3;
+
+loop xb do
+  xa := xa + 1
+end

data/lib/fruitloop.rb

@@ -0,0 +1,8 @@
+$:.unshift(File.join(File.dirname(__FILE__)))
+
+require "lexer"
+require "parser"
+
+lexer = Lexer.new
+parser = Parser.new(lexer)
+parser.parse_start

data/lib/gen/jsvisitor.rb

@@ -0,0 +1,53 @@
+require 'gen/symboltable'
+
+class JSVisitor
+
+  def initialize
+    @target = ""
+    @loop_counter = 0
+  end
+
+  def visit_start(node)
+    compile "sys = require('sys');"
+    compile "xa = 0;"
+    compile "/* adding null initializers */"
+    SymbolTable.null_initializers.each do |token|
+      compile "#{token.name} = 0;" 
+    end
+  end
+
+  def visit_assignment(node)
+    if node.rvalue
+      compile "#{node.lvalue.name} = #{node.rvalue.number};"
+    else
+      compile "#{node.lvalue.name} = #{node.op1.name} #{node.op.op} #{node.op2.number}; "
+    end
+  end
+
+  def visit_loop_start(node)
+    compile "_loopTerminate#{@loop_counter} = #{node.to.name};"
+    compile "for(var _loopVar#{@loop_counter} = 0; _loopVar#{@loop_counter} < _loopTerminate#{@loop_counter}; _loopVar#{@loop_counter}++) {"
+    @loop_counter += 1
+  end
+
+  def visit_loop_end(node)
+    compile "}"
+  end
+
+  def run
+    compile "sys.puts(\"xa: \" + xa);"
+    nodejs = IO.popen("/usr/local/bin/node", "r+")
+    nodejs.puts @target
+    nodejs.close_write
+    puts nodejs.gets
+  end
+
+
+  private
+
+  def compile(source)
+    #p source
+    @target += "#{source}"
+  end
+
+end

data/lib/gen/symboltable.rb

@@ -0,0 +1,20 @@
+class SymbolTable
+
+  @@symbols = {}
+  @@identifiers = []
+
+  def self.get_id(sym_or_tk)
+    @@symbols[sym_or_tk.is_a?(Token) ? sym_or_tk.name : sym_or_tk]
+  end
+
+  def self.add_id token
+    @@symbols[token.name] = token
+  end
+
+  def self.add_null_initializer token
+    @@identifiers << token 
+  end
+
+  def self.null_initializers; @@identifiers; end; 
+
+end

data/lib/lexer.rb

@@ -0,0 +1,105 @@
+require "token/all"
+
+
+# Scanner-Komponente
+# Liefert bei einem Aufruf von "input_token" immer das nächste Token im Quellprogramm. 
+class Lexer
+
+  attr_accessor :lexem, :char, :state
+
+  def initialize 
+    @source = ""
+    read_input(ARGV.first)
+    @pos = -1
+  end
+
+
+  # Gibt das nächste Token der Eingabe zurück
+  def input_token
+
+    self.state = :start
+    next_char
+
+    while true
+
+      # puts "state: #{state}, char: #{char}, lexem: #{lexem}"
+
+      case state
+        when :start then
+          case char
+            when ":" then self.state = :colon
+            when "=" then self.state = :eq
+            when /[+|-]/ then self.state = :binop
+            when ";" then self.state = :semicolon
+            when "@" then self.state = :terminate
+            when /[a-z]/ then
+              self.lexem = char
+              self.state = :identifier_start
+            when /[0-9]/ then
+              self.lexem = char
+              self.state = :number_start
+            else next_char
+          end
+        when :colon then return TColon.new
+        when :eq then return TEq.new
+        when :binop then return TBinOp.new(char)
+        when :semicolon then return TSemicolon.new
+        when :identifier_start then
+          if next_char =~ /[a-z]/
+            self.lexem += char
+          else
+            self.state = :identifier
+            @pos -= 1
+          end
+        when :identifier then
+            l = get_and_clear_lexem
+            return case l
+              when "loop" then TLoop.new
+              when "do" then TDo.new
+              when "end" then TEnd.new
+              else TIdentifier.new(l)
+            end
+        when :number_start then
+          if next_char =~ /[0-9]/ then
+            self.lexem += char
+          else
+            @pos -= 1
+            self.state = :number 
+          end
+        when :number then
+          l = get_and_clear_lexem
+          return TNumber.new(l)
+        when :terminate then return TTerminate.new
+      end
+    end
+  end
+
+
+  private
+
+  # Gibt das aktuelle Lexem zurück. Löscht zusätzlich die Instanzvariable.
+  def get_and_clear_lexem
+    lex = self.lexem 
+    self.lexem = ""
+    lex 
+  end
+
+  # Reader-Methode die das aktuelle Zeichen liefert
+  def char; @c; end;
+
+  # Liest den Quellcode
+  def read_input(file); @source = open(file).read; end;
+
+  # Liefert das nächste Zeichen der Eingabe
+  def next_char
+    if @pos <= @source.length-1
+      @pos += 1
+      @c = @source.slice(@pos, 1)
+    else
+      @c = "@"
+    end
+    @c 
+  end
+
+end
+

data/lib/mult.loop

@@ -0,0 +1,9 @@
+a := a + 5;
+b := b + 8;
+
+loop a do
+  loop b do
+    xa := xa + 1
+  end
+end
+

data/lib/nodes/node_assignment.rb

@@ -0,0 +1,11 @@
+
+class NodeAssignment
+  
+  attr_accessor :lvalue # will always be present with either...
+  attr_accessor :op1, :op, :op2 # ... formal correct version or... 
+  attr_accessor :rvalue # ... the normal version :) 
+
+  def accept(visitor)
+    visitor.visit_assignment self
+  end
+end

data/lib/nodes/node_loop.rb

@@ -0,0 +1,11 @@
+class NodeLoop < ParentNode
+  attr_accessor :to
+
+  def accept(visitor)
+    visitor.visit_loop_start self
+    stmts.each do |stmt|
+      stmt.accept visitor
+    end
+    visitor.visit_loop_end self
+  end
+end

data/lib/nodes/node_parent.rb

@@ -0,0 +1,12 @@
+class ParentNode
+
+  attr_accessor :stmts
+
+  def initialize
+    @stmts = []
+  end
+
+  def <<(it)
+    @stmts << it
+  end
+end

data/lib/nodes/node_start.rb

@@ -0,0 +1,8 @@
+class NodeStart < ParentNode
+  def accept(visitor)
+    visitor.visit_start self
+    stmts.each do |stmt|
+      stmt.accept visitor
+    end
+  end
+end

data/lib/parser.rb

@@ -0,0 +1,176 @@
+require "nodes/node_parent"
+require "nodes/node_assignment"
+require "nodes/node_loop"
+require "nodes/node_start"
+require "gen/jsvisitor"
+
+
+
+class Parser
+
+  attr_reader :lookahead
+
+  def initialize(lexer)
+    @lexer = lexer
+  end
+
+  def test_tokens
+    while @token = @lexer.input_token
+      p @token
+      break if @token.is_a?TTerminate 
+    end
+  end
+
+  # Parsing method for the start production
+  def parse_start
+    consume_token
+    case lookahead 
+      when TIdentifier, TLoop then
+        @node_start = NodeStart.new # The AST´s root node
+        parse_p @node_start
+        match TTerminate 
+      else
+        parse_error
+    end
+
+    # Evaluate AST after the syntax is good
+    traverse_ast 
+  end
+
+
+  def parse_p parent_node
+    case lookahead
+      when TIdentifier then
+        @node_assignment = NodeAssignment.new
+        @node_assignment.lvalue = lookahead
+        SymbolTable.add_id lookahead 
+        parent_node << @node_assignment # Assignment node
+        match TIdentifier
+        parse_a
+        parse_x parent_node
+      when TLoop then
+        @node_loop = NodeLoop.new
+        parent_node << @node_loop # Loop node
+        match TLoop
+        to = lookahead
+        semantic_error "loop variable must be defined" unless SymbolTable.get_id(to) 
+        @node_loop.to = to 
+        match TIdentifier
+        match TDo
+        parse_p @node_loop 
+        match TEnd
+        parse_x parent_node 
+      else
+        parse_error
+    end
+  end
+
+
+  # As x can evaluate to Epsilon...
+  def parse_x parent_node
+    case lookahead
+      when TSemicolon then # ... besides the case that it is not Epsilon ...
+        match TSemicolon
+        parse_p parent_node
+        parse_x parent_node 
+      when TTerminate, TEnd, TSemicolon then # ... predict for the follow set.
+        # Epsilon production
+      else
+        # Error - the current lookahead is neither in..
+        # 1. FIRST(x)
+        # 2. FOLLOW(x) if Epsilon in FIRST(x)  
+      parse_error 
+    end
+  end
+
+
+  def parse_a
+    case lookahead
+      when TColon then
+        match TColon
+        parse_b
+      else
+        parse_error
+    end
+  end
+
+
+  def parse_b
+    case lookahead
+      when TEq then
+        match TEq
+        parse_c
+      else
+        parse_error
+    end
+  end
+
+
+  def parse_c
+    case lookahead
+      when TIdentifier
+        SymbolTable.add_null_initializer lookahead
+        @node_assignment.op1 = lookahead # An assignment´s first operand
+        match TIdentifier
+        parse_d
+      when TNumber
+        @node_assignment.rvalue = lookahead # Short assignment
+        match TNumber
+      else
+        parse_error
+    end
+  end
+
+
+  def parse_d
+    case lookahead
+      when TBinOp then
+        @node_assignment.op = lookahead # Operand
+        match TBinOp
+        @node_assignment.op2 = lookahead # An assignment´s second operand
+        match TNumber
+      else
+        parse_error
+    end
+  end
+
+
+  private
+
+  # Checks if the current token is an instance of <which_class>. If this is not the case
+  # the programm terminates as an syntacial error occured. Reads the next token after the
+  # check was successful.
+  def match(which_class)
+    if lookahead.is_a?(which_class)
+      #p "Is: #{lookahead.class}, Expected: #{which_class}"
+    else
+      p "Syntaxfehler! Is: #{lookahead.class} Expected: #{which_class}" 
+      exit
+    end
+    consume_token
+  end
+
+  # Returns the next token from the scanner
+  def consume_token
+    @lookahead = @lexer.input_token 
+    @lookahead 
+  end
+
+  def parse_error
+    p "Syntax error: #{lookahead.class}"
+    exit 
+  end
+
+  def semantic_error(message)
+    p "Semantic error: #{message}"
+    exit 
+  end
+
+  def traverse_ast
+    visitor = JSVisitor.new
+    @node_start.accept visitor
+    visitor.run
+  end
+
+
+end

data/lib/sub.loop

@@ -0,0 +1,6 @@
+xa := 7;
+xb := 1;
+
+loop xb do
+  xa := xa - 1
+end

data/lib/token/all.rb

@@ -0,0 +1,32 @@
+class Token
+  attr_accessor :line, :row 
+end
+
+class TIdentifier < Token
+  attr_accessor :name
+  def initialize(name)
+    @name = name
+  end
+end
+
+class TNumber  < Token
+  attr_accessor :number
+  def initialize(number)
+    @number = number
+  end
+end
+
+class TBinOp < Token
+  attr_accessor :op
+  def initialize(op)
+    @op = op
+  end
+end
+
+class TColon < Token; end;
+class TEq < Token; end;
+class TTerminate < Token; end;
+class TEnd < Token; end;
+class TLoop < Token; end;
+class TDo < Token; end;
+class TSemicolon < Token; end;

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: fruitloop
+version: !ruby/object:Gem::Version
+  version: '0.3'
+  prerelease: 
+platform: ruby
+authors:
+- Thomas Hoefer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-12 00:00:00.000000000 +02:00
+default_executable: 
+dependencies: []
+description: FRUITLOOP is an implementation of the LOOP programming language.
+email: mail@tomhoefer.de
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- MIT-LICENSE
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/add.loop
+- lib/fruitloop.rb
+- lib/gen/jsvisitor.rb
+- lib/gen/symboltable.rb
+- lib/lexer.rb
+- lib/mult.loop
+- lib/nodes/node_assignment.rb
+- lib/nodes/node_loop.rb
+- lib/nodes/node_parent.rb
+- lib/nodes/node_start.rb
+- lib/parser.rb
+- lib/sub.loop
+- lib/token/all.rb
+has_rdoc: true
+homepage: http://www.github.com/thoefer/fruitloop
+licenses: []
+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.6.2
+signing_key: 
+specification_version: 3
+summary: FRUITLOOP is an implementation of the LOOP programming language.
+test_files: []