rltk 1.2.0 → 2.0.0

data/lib/rltk/token.rb

@@ -12,16 +12,30 @@ module RLTK # :nodoc:
 	# The StreamPosition class is used to indicate the position of a token or
 	# other text inside a stream.
 	class StreamPosition
+		# @return [Integer]
 		attr_accessor :stream_offset
+		
+		# @return [Integer]
 		attr_accessor :line_number
+		
+		# @return [Integer]
 		attr_accessor :line_offset
+		
+		# @return [Integer]
 		attr_accessor :length
 		
+		# @return [String]
 		attr_accessor :file_name
 		
 		alias :start :line_offset
 		
 		# Instantiates a new StreamPosition object with the values specified.
+		#
+		# @param [Integer]		stream_offset	The position from the beginning of the stream.
+		# @param [Integer]		line_number	The number of newlines since the beginning of the file.
+		# @param [Integer]		line_offset	The offset of this token from the beginning of the current line.
+		# @param [Integer]		length		The length of the text of the token.
+		# @param [String, nil]	file_name		The name of the file being lexed.
 		def initialize(stream_offset = 0, line_number = 0, line_offset = 0, length = 0, file_name = nil)
 			@stream_offset	= stream_offset
 			@line_number	= line_number
@@ -34,13 +48,20 @@ module RLTK # :nodoc:
 	# The Token class is used to represent the output of a RLTK::Lexer and the
 	# input of a RLTK::Parser.
 	class Token
+		# @return [Symbol]
 		attr_reader :type
+		
+		# @return [Symbol]
 		attr_reader :value
 		
-		# The StreamPosition object associated with this token.
+		# @return [StreamPosition] StreamPosition object associated with this token.
 		attr_reader :position
 		
 		# Instantiates a new Token object with the values specified.
+		#
+		# @param [Symbol]				type		A symbol representing the type of this Token.
+		# @param [Object, nil]			value	A value associated with this token.
+		# @param [StreamPosition, nil]	position	The position of the token in a stream.
 		def initialize(type, value = nil, position = nil)
 			@type	= type
 			@value	= value
@@ -48,13 +69,17 @@ module RLTK # :nodoc:
 			@position	= position
 		end
 		
-		# Compares one token to another.  This only tests the token's _type_
-		# and _value_ and not the location of the token in its source.
+		# Compares one token to another.  This only tests the token's *type*
+		# and *value* and not the location of the token in its source.
+		#
+		# @param [Token] other Another Token to compare to.
+		#
+		# @return [Boolean]
 		def ==(other)
 			self.type == other.type and self.value == other.value
 		end
 		
-		# Returns a string representing the tokens _type_ and _value_.
+		# @return [String] String representing the tokens *type* and *value*.
 		def to_s
 			if value
 				"#{self.type}(#{self.value})"

data/lib/rltk/util/abstract_class.rb

@@ -0,0 +1,25 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2012/04/20
+# Description:	This file holds an implementation of an AbstractClass module.
+
+# A module used for making abstract classes.  Any class that includes this
+# module will not be able to be instantiated directly.
+module AbstractClass
+	# Callback method for when this module is included.
+	#
+	# @param [Class] klass The Class object for the including class.
+	def self.included(klass)
+		klass.instance_exec do
+			@abstract_class = klass
+			
+			def self.new(*args)
+				if self == @abstract_class
+					raise "Instantiating abstract class #{self} is not allowed."
+				else
+					super
+				end
+			end
+		end
+	end
+end

data/lib/rltk/util/monkeys.rb

@@ -0,0 +1,125 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2012/03/08
+# Description:	This file holds various monkey patches that make coding easier.
+
+############
+# Requires #
+############
+
+###########
+# Methods #
+###########
+
+# A helper method for type checking Ruby values.
+#
+# @param [Object]		o		Object to type check.
+# @param [Class]		type		Class the object should be an instance of.
+# @param [String, nil]	blame	Variable name to blame for failed type checks.
+# @param [Boolean]		strict	Strict or non-strict checking.  Uses `instance_of?` and `is_a?` respectively.
+#
+# @return [Object] The object passed as parameter o.
+def check_type(o, type, blame = nil, strict = false)
+	type_ok = if strict then o.instance_of?(type) else o.is_a?(type) end
+	
+	if type_ok
+		o
+	else
+		if blame
+			raise "Parameter #{blame} must be an instance of the #{type.name} class.  Received an instance of #{o.class.name}."
+		else
+			raise "Expected an object of type #{type.name}.  Received an instance of #{o.class.name}."
+		end
+	end
+end
+
+# A helper method for type checking Ruby array values.
+#
+# @param [Array<Object>]	array	Array of objects to type check.
+# @param [Class]		type		Class the objects should be an instance of.
+# @param [String, nil]	blame	Variable name to blame for failed type checks.
+# @param [Boolean]		strict	Strict or non-strict checking.  Uses `instance_of?` and `is_a?` respectively.
+#
+# @return [Object] The object passed in parameter o.
+def check_array_type(array, type, blame = nil, strict = false)
+	array.each do |o|
+		type_ok = if strict then o.instance_of?(type) else o.is_a?(type) end
+		
+		if not type_ok
+			if blame
+				raise "Parameter #{blame} must contain instances of the #{type.name} class."
+			else
+				raise "Expected an object of type #{type.name}."
+			end
+		end
+	end
+end
+
+#######################
+# Classes and Modules #
+#######################
+
+# Monkey-patched Object class.
+class Object
+	# Simple implementation of the Y combinator.
+	#
+	# @param [Object] value Value to be returned after executing the provided block.
+	#
+	# @return [Object] The object passed in parameter value.
+	def returning(value)
+		yield(value)
+		value
+	end
+end
+
+# Monkey-patched Class class.
+class Class
+	# Checks for module inclusion.
+	#
+	# @param [Module] mod Module to check the inclusion of.
+	def includes_module?(mod)
+		self.included_modules.include?(mod)
+	end
+	
+	# @return [String] Name of class without the namespace.
+	def short_name
+		self.name.split('::').last
+	end
+	
+	# Checks to see if a Class object is a subclass of the given class.
+	#
+	# @param [Class] klass Class we are checking if this is a subclass of.
+	def subclass_of?(klass)
+		raise 'The klass parameter must be an instance of Class.' if not klass.is_a?(Class)
+		
+		if (superklass = self.superclass)
+			superklass == klass or superklass.subclass_of?(klass)
+		else
+			false
+		end
+	end
+end
+
+# Monkey-patchec Integer class.
+class Integer
+	# @return [Boolean] This Integer as a Boolean value.
+	def to_bool
+		self != 0
+	end
+end
+
+# Monkey-patched TrueClass class.
+class TrueClass
+	# @return [1]
+	def to_i
+		1
+	end
+end
+
+# Monkey-patched FalseClass class.
+class FalseClass
+	# @return [0]
+	def to_i
+		0
+	end
+end

data/lib/rltk/version.rb

@@ -3,6 +3,9 @@
 # Date:		2012/03/08
 # Description:	This file specifies the version number of RLTK.
 
-module RLTK
-	VERSION = "1.2.0"
+module RLTK # :nodoc:
+	# The version number of the RLTK library.
+	VERSION			= '2.0.0'
+	# The version of LLVM targeted by RLTK.
+	LLVM_TARGET_VERSION	= '3.0'
 end

data/test/tc_ast.rb

@@ -18,17 +18,17 @@ require 'rltk/ast'
 # Classes and Modules #
 #######################
 
-class ANode < RLTK::ASTNode
-	child :left, ANode
-	child :right, ANode
-end
-
-class BNode < ANode; end
-class CNode < ANode; end
+class ASTNodeTester < Test::Unit::TestCase
+	class ANode < RLTK::ASTNode
+		child :left, ANode
+		child :right, ANode
+	end
 
-class DNode < RLTK::ASTNode; end
+	class BNode < ANode; end
+	class CNode < ANode; end
 
-class ASTNodeTester < Test::Unit::TestCase
+	class DNode < RLTK::ASTNode; end
+	
 	def setup
 		@leaf0 = CNode.new(nil, nil)
 		@tree0 = ANode.new(BNode.new(@leaf0, nil), BNode.new(nil, nil))
@@ -63,8 +63,8 @@ class ASTNodeTester < Test::Unit::TestCase
 	end
 	
 	def test_initialize
-		assert_raise(Exception) { RLTK::ASTNode.new }
-		assert_nothing_raised(Exception) { ANode.new(nil, nil) }
+		assert_raise(RuntimeError) { RLTK::ASTNode.new }
+		assert_nothing_raised(RuntimeError) { ANode.new(nil, nil) }
 	end
 	
 	def test_notes

data/test/tc_lexer.rb

@@ -20,61 +20,61 @@ require 'rltk/lexers/ebnf'
 # Classes and Modules #
 #######################
 
-class ABLongest < RLTK::Lexer
-	rule(/a+/)	{ :APLUS }
-	rule(/b+/)	{ :BPLUS }
+class LexerTester < Test::Unit::TestCase
+	class ABLongest < RLTK::Lexer
+		rule(/a+/)	{ :APLUS }
+		rule(/b+/)	{ :BPLUS }
 	
-	rule(/a+b+/)	{ :APLUSBPLUS }
-end
+		rule(/a+b+/)	{ :APLUSBPLUS }
+	end
 
-class ABFirst < RLTK::Lexer
-	match_first
+	class ABFirst < RLTK::Lexer
+		match_first
 	
-	rule(/a+/)	{ :APLUS }
-	rule(/b+/)	{ :BPLUS }
+		rule(/a+/)	{ :APLUS }
+		rule(/b+/)	{ :BPLUS }
 	
-	rule(/a+b+/)	{ :APLUSBPLUS }
-end
+		rule(/a+b+/)	{ :APLUSBPLUS }
+	end
 
-class ENVLexer < RLTK::Lexer
-	rule(/a/)	{ [:A, next_value] }
+	class ENVLexer < RLTK::Lexer
+		rule(/a/)	{ [:A, next_value] }
 	
-	class Environment < Environment
-		def initialize(*args)
-			super(*args)
-			@value = -1
-		end
-		
-		def next_value
-			@value += 1
+		class Environment < Environment
+			def initialize(*args)
+				super(*args)
+				@value = -1
+			end
+		
+			def next_value
+				@value += 1
+			end
 		end
 	end
-end
 
-class FlagLexer < RLTK::Lexer
-	rule(/a/)		{ set_flag(:a); :A }
-	rule(/\s/)
+	class FlagLexer < RLTK::Lexer
+		rule(/a/)		{ set_flag(:a); :A }
+		rule(/\s/)
 	
-	rule(/b/, :default, [:a])	{ set_flag(:b); :B }
-	rule(/c/, :default, [:a, :b])	{ :C }
-end
+		rule(/b/, :default, [:a])	{ set_flag(:b); :B }
+		rule(/c/, :default, [:a, :b])	{ :C }
+	end
 
-class StateLexer < RLTK::Lexer
-	rule(/a/)		{ :A }
-	rule(/\s/)
+	class StateLexer < RLTK::Lexer
+		rule(/a/)		{ :A }
+		rule(/\s/)
 	
-	rule(/\(\*/)	{ push_state(:comment) }
+		rule(/\(\*/)	{ push_state(:comment) }
 	
-	rule(/\(\*/, :comment)	{ push_state(:comment) }
-	rule(/\*\)/, :comment)	{ pop_state }
-	rule(/./,    :comment)
-end
-
-class MatchDataLexer < RLTK::Lexer
-	rule(/a(b*)(c+)/) { [:FOO, match[1,2]] }
-end
+		rule(/\(\*/, :comment)	{ push_state(:comment) }
+		rule(/\*\)/, :comment)	{ pop_state }
+		rule(/./,    :comment)
+	end
 
-class LexerTester < Test::Unit::TestCase
+	class MatchDataLexer < RLTK::Lexer
+		rule(/a(b*)(c+)/) { [:FOO, match[1,2]] }
+	end
+	
 	def test_calc
 		expected =
 			[

data/test/tc_parser.rb

@@ -8,8 +8,8 @@
 ############
 
 # Standard Library
-require 'pp'
 require 'test/unit'
+require 'tmpdir'
 
 # Ruby Language Toolkit
 require 'rltk/lexer'
@@ -23,130 +23,130 @@ require 'rltk/parsers/postfix_calc'
 # Classes and Modules #
 #######################
 
-class ABLexer < RLTK::Lexer
-	rule(/a/) { [:A, 1] }
-	rule(/b/) { [:B, 2] }
-	
-	rule(/\s/)
-end
-
-class APlusBParser < RLTK::Parser
-	production(:a, 'A+ B') { |a, _| a.length }
-	
-	finalize
-end
-
-class AQuestionBParser < RLTK::Parser
-	production(:a, 'A? B') { |a, _| a }
+class ParserTester < Test::Unit::TestCase
+	class ABLexer < RLTK::Lexer
+		rule(/a/) { [:A, 1] }
+		rule(/b/) { [:B, 2] }
+		
+		rule(/\s/)
+	end
 	
-	finalize
-end
-
-class AStarBParser < RLTK::Parser
-	production(:a, 'A* B') { |a, _| a.length }
+	class APlusBParser < RLTK::Parser
+		production(:a, 'A+ B') { |a, _| a.length }
+		
+		finalize
+	end
 	
-	finalize
-end
-
-class AmbiguousParser < RLTK::Parser
-	production(:e) do
-		clause('NUM') {|n| n}
-		
-		clause('e PLS e') { |e0, _, e1| e0 + e1 }
-		clause('e SUB e') { |e0, _, e1| e0 - e1 }
-		clause('e MUL e') { |e0, _, e1| e0 * e1 }
-		clause('e DIV e') { |e0, _, e1| e0 / e1 }
+	class AQuestionBParser < RLTK::Parser
+		production(:a, 'A? B') { |a, _| a }
+		
+		finalize
 	end
 	
-	finalize
-end
-
-class ArrayCalc < RLTK::Parser
-	array_args
+	class AStarBParser < RLTK::Parser
+		production(:a, 'A* B') { |a, _| a.length }
+		
+		finalize
+	end
 	
-	production(:e) do
-		clause('NUM') { |v| v[0] }
+	class AmbiguousParser < RLTK::Parser
+		production(:e) do
+			clause('NUM') {|n| n}
+			
+			clause('e PLS e') { |e0, _, e1| e0 + e1 }
+			clause('e SUB e') { |e0, _, e1| e0 - e1 }
+			clause('e MUL e') { |e0, _, e1| e0 * e1 }
+			clause('e DIV e') { |e0, _, e1| e0 / e1 }
+		end
 		
-		clause('PLS e e') { |v| v[1] + v[2] }
-		clause('SUB e e') { |v| v[1] - v[2] }
-		clause('MUL e e') { |v| v[1] * v[2] }
-		clause('DIV e e') { |v| v[1] / v[2] }
+		finalize
 	end
 	
-	finalize
-end
-
-class DummyError1 < Exception; end
-class DummyError2 < Exception; end
-
-class ErrorCalc < RLTK::Parser
-	production(:e) do
-		clause('NUM') {|n| n}
+	class ArrayCalc < RLTK::Parser
+		array_args
+		
+		production(:e) do
+			clause('NUM') { |v| v[0] }
 		
-		clause('e PLS e') { |e0, _, e1| e0 + e1 }
-		clause('e SUB e') { |e0, _, e1| e0 - e1 }
-		clause('e MUL e') { |e0, _, e1| e0 * e1 }
-		clause('e DIV e') { |e0, _, e1| e0 / e1 }
+			clause('PLS e e') { |v| v[1] + v[2] }
+			clause('SUB e e') { |v| v[1] - v[2] }
+			clause('MUL e e') { |v| v[1] * v[2] }
+			clause('DIV e e') { |v| v[1] / v[2] }
+		end
 		
-		clause('e PLS ERROR') { |_, _, _| raise DummyError1 }
-		clause('e SUB ERROR') { |_, _, _| raise DummyError2 }
+		finalize
 	end
 	
-	finalize
-end
+	class DummyError1 < StandardError; end
+	class DummyError2 < StandardError; end
+	
+	class ErrorCalc < RLTK::Parser
+		production(:e) do
+			clause('NUM') {|n| n}
+		
+			clause('e PLS e') { |e0, _, e1| e0 + e1 }
+			clause('e SUB e') { |e0, _, e1| e0 - e1 }
+			clause('e MUL e') { |e0, _, e1| e0 * e1 }
+			clause('e DIV e') { |e0, _, e1| e0 / e1 }
+		
+			clause('e PLS ERROR') { |_, _, _| raise DummyError1 }
+			clause('e SUB ERROR') { |_, _, _| raise DummyError2 }
+		end
+	
+		finalize
+	end
 
-class ELLexer < RLTK::Lexer
-	rule(/\n/)	{ :NEWLINE }
-	rule(/;/)		{ :SEMI    }
+	class ELLexer < RLTK::Lexer
+		rule(/\n/)	{ :NEWLINE }
+		rule(/;/)		{ :SEMI    }
 	
-	rule(/\s/)
+		rule(/\s/)
 	
-	rule(/[A-Za-z]+/)	{ |t| [:WORD, t] }
-end
+		rule(/[A-Za-z]+/)	{ |t| [:WORD, t] }
+	end
 
-class ErrorLine < RLTK::Parser
+	class ErrorLine < RLTK::Parser
 	
-	production(:s, 'line*') { |l| l }
+		production(:s, 'line*') { |l| l }
 	
-	production(:line) do
-		clause('NEWLINE') { |_| nil }
+		production(:line) do
+			clause('NEWLINE') { |_| nil }
 		
-		clause('WORD+ SEMI NEWLINE')	{ |w, _, _| w }
-		clause('WORD+ ERROR NEWLINE')	{ |w, e, _| error(pos(1).line_number); w }
-	end
+			clause('WORD+ SEMI NEWLINE')	{ |w, _, _| w }
+			clause('WORD+ ERROR NEWLINE')	{ |w, e, _| error(pos(1).line_number); w }
+		end
 	
-	finalize
-end
-
-class RotatingCalc < RLTK::Parser
-	production(:e) do
-		clause('NUM') {|n| n}
-		
-		clause('PLS e e') { |_, e0, e1| e0.send(get_op(:+), e1) }
-		clause('SUB e e') { |_, e0, e1| e0.send(get_op(:-), e1) }
-		clause('MUL e e') { |_, e0, e1| e0.send(get_op(:*), e1) }
-		clause('DIV e e') { |_, e0, e1| e0.send(get_op(:/), e1) }
+		finalize
 	end
-	
-	class Environment < Environment
-		def initialize
-			@map = { :+ => 0, :- => 1, :* => 2, :/ => 3 }
-			@ops = [ :+, :-, :*, :/ ]
+
+	class RotatingCalc < RLTK::Parser
+		production(:e) do
+			clause('NUM') {|n| n}
+		
+			clause('PLS e e') { |_, e0, e1| e0.send(get_op(:+), e1) }
+			clause('SUB e e') { |_, e0, e1| e0.send(get_op(:-), e1) }
+			clause('MUL e e') { |_, e0, e1| e0.send(get_op(:*), e1) }
+			clause('DIV e e') { |_, e0, e1| e0.send(get_op(:/), e1) }
 		end
+	
+		class Environment < Environment
+			def initialize
+				@map = { :+ => 0, :- => 1, :* => 2, :/ => 3 }
+				@ops = [ :+, :-, :*, :/ ]
+			end
 		
-		def get_op(orig_op)
-			new_op = @ops[@map[orig_op]]
+			def get_op(orig_op)
+				new_op = @ops[@map[orig_op]]
 			
-			@ops = @ops[1..-1] << @ops[0]
+				@ops = @ops[1..-1] << @ops[0]
 			
-			new_op
+				new_op
+			end
 		end
+	
+		finalize
 	end
 	
-	finalize
-end
-
-class ParserTester < Test::Unit::TestCase
 	def test_ambiguous_grammar
 		actual = AmbiguousParser.parse(RLTK::Lexers::Calculator.lex('1 + 2 * 3'), {:accept => :all})
 		assert_equal([7, 9], actual.sort)
@@ -272,4 +272,30 @@ class ParserTester < Test::Unit::TestCase
 		
 		assert_raise(RLTK::NotInLanguage) { RLTK::Parsers::PrefixCalc.parse(RLTK::Lexers::Calculator.lex('1 + 2 * 3')) }
 	end
+	
+	def test_use
+		tmpfile = File.join(Dir.tmpdir, 'usetest')
+		
+		parser0 = Class.new(RLTK::Parser) do
+			production(:a, 'A+') { |a| a.length }
+			
+			finalize :use => tmpfile
+		end
+		
+		result0 = parser0.parse(ABLexer.lex('a'))
+		
+		assert(File.exist?(tmpfile), 'Serialized parser file not found.')
+		
+		parser1 = Class.new(RLTK::Parser) do
+			production(:a, 'A+') { |a| a.length }
+			
+			finalize :use => tmpfile
+		end
+		
+		result1 = parser1.parse(ABLexer.lex('a'))
+		
+		assert_equal(result0, result1)
+		
+		File.unlink(tmpfile)
+	end
 end

data/test/ts_rltk.rb

@@ -0,0 +1,50 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2011/04/06
+# Description:	This file contains the test suit for RLTK.  It requires the
+#			individual tests from their respective files.
+
+############
+# Requires #
+############
+
+if RUBY_VERSION[0..2] == '1.9'
+	begin
+		require 'simplecov'
+		SimpleCov.start do
+			add_filter 'tc_*'
+			add_filter 'generated*'
+		end
+		
+	rescue LoadError
+		puts 'SimpleCov not installed.  Continuing without it.'
+	end
+end
+
+# Rubygems
+require 'rubygems'
+require 'ffi'
+
+# Ruby Language Toolkit
+require 'rltk/version'
+
+# Test cases
+require 'tc_token'
+require 'tc_ast'
+require 'tc_cfg'
+require 'tc_lexer'
+require 'tc_parser'
+
+require 'util/ts_util'
+
+begin
+	class Tester
+		extend FFI::Library
+		
+		ffi_lib("LLVM-#{RLTK::LLVM_TARGET_VERSION}")
+	end
+	
+	# The test suite for the LLVM bindings
+	require 'cg/ts_cg'
+rescue
+end