purple-lang 0.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+*.gem
+

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/Gemfile.lock

@@ -0,0 +1,41 @@
+PATH
+  remote: .
+  specs:
+    purple (0.0.1)
+      treetop
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    awesome_print (1.1.0)
+    coderay (1.0.8)
+    diff-lcs (1.1.3)
+    method_source (0.8.1)
+    polyglot (0.3.3)
+    pry (0.9.10)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.3.1)
+    rake (0.9.2.2)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.3)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.3)
+    slop (3.3.3)
+    treetop (1.4.12)
+      polyglot
+      polyglot (>= 0.3.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  awesome_print
+  pry
+  purple!
+  rake
+  rspec

data/README.md

@@ -0,0 +1,25 @@
+purple
+======
+
+a programming language being built for fun.
+
+## current features
+- basic arithmetic
+- variable assignment
+
+## run example
+```
+bin/purple examples/basic.ppl
+```
+
+## install from gem
+```
+sudo gem install purple
+purple <source-file>
+```
+
+## run the tests
+```bash
+bundle install && bundle exec rake spec
+```
+

data/Rakefile

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = Dir.glob('spec/**/*_spec.rb')
+  t.rspec_opts = '--color'
+end

data/bin/purple

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+$:.push File.join(File.dirname(__FILE__), '../lib')
+require 'purple'
+
+# TODO: proper commandline-fu (options, help, etc.)
+raise "must provide a source file name as argument" unless ARGV.length > 0
+source = File.read(ARGV.first)
+puts Purple::SexpVM.new.evaluate(Parser.parse(source))

data/bin/ruby_sexp.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+require 'ripper'
+require 'ap'
+require 'pry'
+
+def sexp(code)
+  ap Ripper.sexp(code)
+end
+
+sexp "x = 5"
+
+binding.pry

data/examples/basic.ppl

@@ -0,0 +1,5 @@
+
+# an example program to test-drive purple
+
+x = 2 * 2 + 15 / 5
+

data/lib/purple.rb

@@ -0,0 +1,3 @@
+require 'purple/parser'
+require 'purple/sexp_vm'
+

data/lib/purple/infix.rb

@@ -0,0 +1,81 @@
+
+module Purple
+  module Infix
+    # apply associativity rules and order of precedence to an sexp.
+    #
+    # e.g. this input:
+    #   [ [:int, 5], :-, [:int, 2], :-, [:int, 1] ]
+    # becomes:
+    #   [ :-, [:-, [:int, 5], [:int, 2]], [:int, 1] ]
+    def self.process_infix(unordered)
+      rpn(shunting_yard unordered)
+    end
+
+    module PrecedenceTable
+      Operator = Struct.new(:precedence, :associativity)
+
+      def self.infix_operator?(operator)
+        !lookup(operator).nil?
+      end
+
+      def self.lookup(operator)
+        @operators[operator]
+      end
+
+      def self.op(associativity, *operators)
+        @precedence ||= 0
+        @operators ||= {}
+        operators.each do |operator|
+          @operators[operator] = Operator.new(@precedence, associativity)
+        end
+        @precedence += 1
+      end
+
+      # operator precedence, low to high
+      #op :left, '||'
+      #op :left, '&&'
+      #op :none, '==', '!='
+      #op :left, '<', '<=', '>', '>='
+      op :left, :+, :-
+      op :left, :*, :/
+      #op :right, '^'
+    end
+
+    def self.rpn(input)
+      results = []
+      input.each do |object|
+        if PrecedenceTable.infix_operator? object
+          r, l = results.pop, results.pop
+          results << [object, l, r]
+        else
+          results << object
+        end
+      end
+      results.first
+    end
+
+    # given an infix expression, apply precedence and associativity
+    # result is in RPN
+    # http://en.wikipedia.org/wiki/Shunting-yard_algorithm
+    def self.shunting_yard(input)
+      [].tap do |rpn|
+        operator_stack = []
+        input.each do |object|
+          if PrecedenceTable.infix_operator? object
+            op1 = object
+            op1_left = PrecedenceTable.lookup(op1).associativity ==  :left
+            op1_prec = PrecedenceTable.lookup(op1).precedence
+            rpn << operator_stack.pop while (op2 = operator_stack.last) &&
+                                            (op2_prec = PrecedenceTable.lookup(op2).precedence) &&
+                                            (op1_left ? op1_prec <= op2_prec : op1_prec < op2_prec)
+            operator_stack << op1
+          else
+            rpn << object
+          end
+        end
+        rpn << operator_stack.pop until operator_stack.empty?
+      end
+    end
+
+  end
+end

data/lib/purple/parser.rb

@@ -0,0 +1,34 @@
+require 'treetop'
+require 'purple/syntax_nodes'
+
+class Parser
+  Treetop.load File.join(File.expand_path(File.dirname __FILE__), 'purple_grammar.treetop')
+  @@parser = PurpleParser.new
+
+  def self.parse(code)
+    tree = @@parser.parse code
+    raise "Parse error at offset: #{@@parser.index} : #{@@parser.failure_reason}" if tree.nil?
+    clean! tree
+    tree.to_a
+  end
+
+  private
+
+  def self.clean!(root)
+    return if root.elements.nil?
+
+    # TODO: this is a hack - fix it
+    # treat infix operation chains specially
+    if root.class == Purple::InfixOperationChain
+      root.elements.map! { |e| [e.primary, e.infix_operator] }
+      root.elements.flatten!
+    end
+
+    # remove stuff which is irrelevant to AST
+    root.elements.reject! { |n| n.class == Treetop::Runtime::SyntaxNode }
+
+    root.elements.each { |n| clean! n }
+  end
+
+end
+

data/lib/purple/purple_grammar.treetop

@@ -0,0 +1,103 @@
+
+grammar Purple
+
+  # program structure
+  rule program
+    (comment / statement)+ <Program>
+  end
+
+  rule statement
+    space? ( assignment ) space? <Statement> /
+    expression
+  end
+
+
+  # literals
+  rule nil
+    'nil' <NilLiteral>
+  end
+
+  rule true
+    'true' <TrueLiteral>
+  end
+
+  rule false
+    'false' <FalseLiteral>
+  end
+
+  rule integer
+    ('+' / '-')? [0-9]+ <IntegerLiteral>
+  end
+
+  # assignment
+  rule assignment
+    identifier space? assignment_operator space? expression <Assignment>
+  end
+
+  # expressions
+  rule expression
+    space? (infix_expression / primary) <Expression>
+  end
+
+  rule infix_expression
+    infix_operation_chain primary <InfixExpression>
+  end
+
+  rule infix_operation_chain
+    (primary space? infix_operator space?)+ <InfixOperationChain>
+  end
+
+  rule primary
+    nil / true / false / identifier / integer
+    /
+    '(' expression ')' <Expression>
+  end
+
+  # operator sets
+  rule infix_operator
+    addition_operator / subtraction_operator / multiplication_operator / division_operator
+  end
+
+  # operators
+  rule assignment_operator
+    '=' <AssignmentOperator>
+  end
+
+ rule addition_operator
+    '+' <AdditionOperator>
+  end
+
+  rule subtraction_operator
+    '-' <SubtractionOperator>
+  end
+
+  rule multiplication_operator
+    '*' <MultiplicationOperator>
+  end
+
+  rule division_operator
+    '/' <DivisionOperator>
+  end
+
+  rule identifier
+    [a-zA-Z]+ <Identifier>
+  end
+
+  rule body
+    (expression / literal / space)* <Body>
+  end
+
+
+  rule space
+    [\s]+
+  end
+
+  rule comment
+    space? '#' [^"\n"]* ( "\n" / eof )
+  end
+
+  rule eof
+    !.
+  end
+
+end

data/lib/purple/sexp_vm.rb

@@ -0,0 +1,49 @@
+
+
+module Purple
+  class SexpVM
+
+    def initialize
+      @vars = {}
+    end
+
+    def evaluate(sexp)
+      f, *args = *sexp
+#ap "x"*80
+#ap f.inspect
+#ap args.inspect
+      ret =case f
+      when :program
+       # TODO: eliminate redundant array surrounding each expr
+       ret = nil
+       args.each { |stmt| ret = evaluate stmt.first }
+       ret
+      when :assign
+        raise 'huh?' unless args.length == 2
+        ident, expr = args.first, args.last
+        name = ident.last
+        @vars[name] = evaluate expr
+      when :int
+        raise 'huh?' unless args.length == 1
+        args.first
+      when :+
+        raise 'huh?' unless args.length == 2
+        evaluate(args.first) + evaluate(args.last)
+      when :-
+        raise 'huh?' unless args.length == 2
+        evaluate(args.first) - evaluate(args.last)
+      when :*
+        raise 'huh?' unless args.length == 2
+        evaluate(args.first) * evaluate(args.last)
+      when :/
+        raise 'huh?' unless args.length == 2
+        evaluate(args.first) / evaluate(args.last)
+      when :ident
+        @vars[args.first]
+      else
+        raise "unknown sexp op: #{f}"
+      end
+    end
+
+  end
+end

data/lib/purple/syntax_nodes.rb

@@ -0,0 +1,68 @@
+require 'purple/infix.rb'
+
+module Purple
+
+  # given a proc which generates ast for a node,
+  # create a subclass of Treetop::Runtime::SyntaxNode for it.
+  #
+  # e.g., these two are equivalent:
+  #   IntegerLiteral = node_def -> { [:int, text_value.to_i] }
+  #
+  #   class FalseLiteral < Treetop::Runtime::SyntaxNode
+  #     def to_a
+  #       [:int, text_value.to_i]
+  #     end
+  #   end
+  def self.node_def(to_ast)
+    klass = Class.new(Treetop::Runtime::SyntaxNode) do
+      @to_a_proc = to_ast
+      def to_a
+        self.instance_exec(&self.class.instance_variable_get(:@to_a_proc))
+      end
+    end
+  end
+
+  Program = node_def -> { [:program] + elements.map { |e| e.to_a } }
+
+  Statement = node_def -> { elements.map { |e| e.to_a } }
+
+  NilLiteral = node_def -> { [:nil] }
+
+  TrueLiteral = node_def -> { [:true] }
+
+  FalseLiteral = node_def -> { [:false] }
+
+  IntegerLiteral = node_def -> { [:int, text_value.to_i] }
+
+  Assignment = node_def -> { [:assign, elements.first.to_a, elements.last.to_a ] }
+
+  InfixExpression = node_def -> {
+    unordered = elements.first.elements.map { |e| e.to_a } << elements.last.to_a
+    Purple::Infix.process_infix unordered
+  }
+
+  InfixOperationChain = node_def -> { elements.map { |e| e.to_a } }
+
+  AssignmentOperator = node_def -> { }
+
+  AdditionOperator = node_def -> { :+ }
+
+  SubtractionOperator = node_def -> { :- }
+
+  MultiplicationOperator = node_def -> { :* }
+
+  DivisionOperator = node_def -> { :/ }
+
+  Identifier = node_def -> { [:ident, text_value] }
+
+  Expression = node_def -> {
+    # TODO: fix this shit
+    if elements.first.class == InfixExpression
+      elements.first.to_a
+    else
+      elements.map { |e| e.to_a }
+    end
+  }
+
+end
+

data/purple-lang.gemspec

@@ -0,0 +1,27 @@
+#
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name        = "purple-lang"
+  s.version     = "0.0.1"
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = [ "Tim Miller" ]
+  s.email       = [ "" ]
+  s.homepage    = "https://github.com/echohead/purple"
+  s.summary     = %q{programming language sandbox}
+  s.description = %q{}
+
+  s.required_ruby_version     = ">= 1.9.3"
+  s.required_rubygems_version = ">= 1.3.7"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency     "treetop",         ">= 0"
+  s.add_development_dependency "rake",            ">= 0"
+  s.add_development_dependency "rspec",           ">= 0"
+  s.add_development_dependency "awesome_print",   ">= 0"
+  s.add_development_dependency "pry",             ">= 0"
+end

data/spec/boolean_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe 'booleans' do
+
+  it 'should parse into sexp' do
+    sexp('true').should == [:true]
+    sexp('false').should == [:false]
+  end
+
+end

data/spec/comment_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe 'comments' do
+  it 'should parse full-lines' do
+    parse("# a comment\nfoo").should == [:program, [[:ident, "foo"]]]
+  end
+
+  it 'should parse at end of line' do
+    parse("foo # <- the foo").should == [:program, [[:ident, "foo"]]]
+  end
+end

data/spec/identifier_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe 'identifiers' do
+  it 'should parse' do
+    sexp('foobar').should == [:ident, "foobar"]
+  end
+end

data/spec/infix_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe 'infix' do
+
+  it 'does left-associativity' do
+    unordered = [ [:int, 5], :-, [:int, 2], :-, [:int, 1] ]
+    out = [ :-, [:-, [:int, 5], [:int, 2]], [:int, 1] ]
+    Purple::Infix.process_infix(unordered).should == out
+  end
+
+  it 'does order of operations' do
+    unordered = [ [:int, 3], :+, [:int, 2], :*, [:int, 5] ]
+    out = [ :+, [:int, 3], [:*, [:int, 2], [:int, 5]] ]
+    Purple::Infix.process_infix(unordered).should == out
+  end
+
+end

data/spec/integer_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+require 'purple'
+
+describe 'integer' do
+
+  it 'should parse into sexp' do
+    sexp('3').should == [:int, 3]
+    sexp('0').should == [:int, 0]
+    sexp('-512').should == [:int, -512]
+    sexp(' 1003456').should == [:int, 1003456]
+  end
+
+end
+
+

data/spec/nil_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe 'nil' do
+
+  it 'should parse into sexp' do
+    sexp('nil').should == [:nil]
+    sexp('  nil').should == [:nil]
+  end
+
+end

data/spec/sandbox_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+code = <<-EOS
+
+  # an example program
+
+  x = 5 - 2 - 1
+EOS
+
+
+sexp = \
+[:program,
+  [
+    # x = 5 - 2 - 1
+    [:assign,
+      [:ident, "x"],
+      [:-,
+        [:-,
+          [:int, 5],
+          [:int, 2]
+        ],
+        [:int, 1]
+      ]
+    ]
+  ]
+]
+
+describe 'sandbox' do
+  it 'should work' do
+    parse(code).should == sexp
+  end
+end

data/spec/sexp_vm_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+
+describe Purple::SexpVM do
+
+  it 'should return the value of an assignment' do
+    Purple::SexpVM.new.evaluate([:assign, [:ident, 'x'], [:int, 5]]).should == 5
+  end
+
+  it 'should do basic arithmetic' do
+    evaluate("x = 1 + 1").should == 2
+    evaluate("x = 10 / 2 - 7 + 3 * 4 + 1\nx").should == 11
+    evaluate("x = (3 - 1) * 2 + (5 * (7 - 2))\nx").should == 29
+  end
+
+end

data/spec/source_layout_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe 'source layout' do
+
+  it 'should allow empty lines' do
+    sexp("\n\nx = \n1\n").should == [:assign, [:ident, "x"], [[:int, 1]]]
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require 'purple'
+require 'rspec'
+require 'ap'
+
+# parse a chunk of code and return its AST representation
+def parse(code)
+  Parser.parse code
+end
+
+# return AST of a single expression, without surrounding boilerplate
+def sexp(code)
+  parse(code).last.first
+end
+
+# evaluate a block of code and return its result
+def evaluate(code)
+  Purple::SexpVM.new.evaluate parse(code)
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: purple-lang
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Tim Miller
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: treetop
+  requirement: &6468740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *6468740
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &6467760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *6467760
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &6467220 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *6467220
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: &6466380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *6466380
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: &6465720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *6465720
+description: ''
+email:
+- ''
+executables:
+- purple
+- ruby_sexp.rb
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/purple
+- bin/ruby_sexp.rb
+- examples/basic.ppl
+- lib/purple.rb
+- lib/purple/infix.rb
+- lib/purple/parser.rb
+- lib/purple/purple_grammar.treetop
+- lib/purple/sexp_vm.rb
+- lib/purple/syntax_nodes.rb
+- purple-lang.gemspec
+- spec/boolean_spec.rb
+- spec/comment_spec.rb
+- spec/identifier_spec.rb
+- spec/infix_spec.rb
+- spec/integer_spec.rb
+- spec/nil_spec.rb
+- spec/sandbox_spec.rb
+- spec/sexp_vm_spec.rb
+- spec/source_layout_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/echohead/purple
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.7
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: programming language sandbox
+test_files: []