rltk 2.0.0 → 2.1.0

data/lib/rltk/cg/triple.rb

@@ -0,0 +1,58 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2012/06/13
+# Description:	This file defines the Triple class.
+
+############
+# Requires #
+############
+
+# Ruby Language Toolkit
+require 'rltk/cg/bindings'
+
+#######################
+# Classes and Modules #
+#######################
+
+module RLTK::CG # :nodoc:
+
+	# Class binding for the LLVM Triple class.
+	class Triple
+		include BindingClass
+		
+		#################
+		# Class Methods #
+		#################
+		
+		# @return [Triple] Object representing the host architecture, vendor, OS, and environment.
+		def self.host
+			@host ||= self.new(Bindings.get_host_triple)
+		end
+		
+		# @return [String] String representation of the host architecture, vendor, OS, and environment.
+		def self.host_string
+			@host_string ||= Bindings.get_host_triple_string
+		end
+		
+		####################
+		# Instance Methods #
+		####################
+		
+		# Create a new triple describing the host architecture, vendor, OS,
+		# and (optionally) environment.
+		#
+		# @param [FFI::Pointer, String] overloaded
+		def initialize(overloaded)
+			@ptr = 
+			case overloaded
+			when FFI::Pointer	then overloaded
+			when String		then Bindings.triple_create(overloaded)
+			end
+		end
+		
+		# @return [String] String representation of this triple.
+		def to_s
+			Bindings.get_triple_string(@ptr)
+		end
+	end
+end

data/lib/rltk/cg/type.rb

@@ -442,7 +442,7 @@ end
 # @param [String]		blame	Variable name to blame for failed type checks.
 # @param [Boolean]		strict	Strict or non-strict checking.  Uses `instance_of?` and `is_a?` respectively.
 #
-# @raise [RuntimeError] An error is raise if a class is passed in parameter *o*
+# @raise [ArgumentError] An error is raise if a class is passed in parameter *o*
 #   that hasn't included the Singleton class, if the class passed in parameter
 #   *type* isn't a sub-class of {RLTK::CG::Type Type}, or if the type check
 #   fails.
@@ -456,10 +456,10 @@ def check_cg_type(o, type = RLTK::CG::Type, blame = 'type', strict = false)
 			if o.includes_module?(Singleton)
 				o.instance
 			else
-				raise "The #{o.name} class (passed as parameter #{blame}) must be instantiated directly."
+				raise ArgumentError, "The #{o.name} class (passed as parameter #{blame}) must be instantiated directly."
 			end
 		else
-			raise "The #{o.name} class (passed as parameter #{blame} does not inherit from the #{type.name} class." 
+			raise ArgumentError, "The #{o.name} class (passed as parameter #{blame} does not inherit from the #{type.name} class." 
 		end
 	else
 		check_type(o, type, blame, strict)
@@ -476,7 +476,7 @@ end
 # @param [String]			blame	Variable name to blame for failed type checks.
 # @param [Boolean]			strict	Strict or non-strict checking.  Uses `instance_of?` and `is_a?` respectively.
 #
-# @raise [RuntimeError] An error is raise if a class is passed in *array* that
+# @raise [ArgumentError] An error is raise if a class is passed in *array* that
 #   hasn't included the Singleton class, if the class passed in parameter
 #   *type* isn't a sub-class of {RLTK::CG::Type Type}, or if the type check
 #   fails.
@@ -491,10 +491,10 @@ def check_cg_array_type(array, type = RLTK::CG::Type, blame = 'el_types', strict
 				if o.includes_module?(Singleton)
 					o.instance
 				else
-					raise "The #{o.name} class (passed in parameter #{blame}) must be instantiated directly."
+					raise ArgumentError, "The #{o.name} class (passed in parameter #{blame}) must be instantiated directly."
 				end
 			else
-				raise "The #{o.name} class (passed in parameter #{blame}) does not inherit from the #{type.name} class."
+				raise ArgumentError, "The #{o.name} class (passed in parameter #{blame}) does not inherit from the #{type.name} class."
 			end
 			
 		else
@@ -503,7 +503,7 @@ def check_cg_array_type(array, type = RLTK::CG::Type, blame = 'el_types', strict
 			if type_ok
 				o
 			else
-				raise "Parameter #{blame} must contain instances of the #{type.name} class."
+				raise ArgumentError, "Parameter #{blame} must contain instances of the #{type.name} class."
 			end
 		end
 	end

data/lib/rltk/cg/value.rb

@@ -60,7 +60,11 @@ module RLTK::CG # :nodoc:
 			Bindings.is_constant(@ptr).to_bool
 		end
 		
-		# Print the LLVM IR representation of this value to standard out.
+		# Print the LLVM IR representation of this value to standard error.
+		# This function is the debugging version of the more general purpose
+		# {#print} method.
+		#
+		# @see #print
 		#
 		# @return [void]
 		def dump
@@ -91,6 +95,26 @@ module RLTK::CG # :nodoc:
 			Bindings.is_null(@ptr).to_bool
 		end
 		
+		# Print the LLVM IR representation of this value to a file.  The file
+		# may be specified via a file name (which will be created or
+		# truncated) or an object that responds to #fileno.
+		#
+		# @LLVMECB
+		#
+		# @param [String, #fileno] io File name or object with a file descriptor to print to.
+		#
+		# @return [void]
+		def print(io = $stdout)
+			case io
+			when String
+				File.open(io, 'w') do |f|
+					Bindings.print_value(@ptr, f.fileno)
+				end
+			else
+				Bindings.print_value(@ptr, io.fileno)
+			end
+		end
+		
 		# Truncate a value to a given type.
 		#
 		# @param [Type] type Type to truncate to.

data/lib/rltk/cg.rb

@@ -14,7 +14,7 @@ module RLTK # :nodoc:
 	# generation functionality is provided by bindings to
 	# [LLVM](http://llvm.org).
 	module CG
-		autoload :BasicBloc,		'rltk/cg/basic_block'
+		autoload :BasicBlock,		'rltk/cg/basic_block'
 		autoload :Bindings,			'rltk/cg/bindings'
 		autoload :Builder,			'rltk/cg/builder'
 		autoload :Context,			'rltk/cg/context'

data/lib/rltk/parser.rb

@@ -100,25 +100,41 @@ module RLTK # :nodoc:
 				
 				@grammar.callback do |p, type, num|
 					@procs[p.id] =
-					[if type == :*
-						if num == :first
-							Proc.new { || [] }
-						else
-							Proc.new { |o, os| [o] + os }
-						end
-					elsif type == :+
-						if num == :first
-							Proc.new { |o| [o] }
-						else
-							Proc.new { |o, os| [o] + os }
-						end
-					elsif type == :'?'
-						if num == :first
-							Proc.new { || nil }
-						else
-							Proc.new { |o| o }
-						end
-					end, p.rhs.length]
+					[
+						case type
+						when :*
+							case num
+							when :first then	Proc.new { ||           [] }
+							else				Proc.new { |os, o| os << o }
+							end
+							
+						when :+
+							case num
+							when :first then	Proc.new { |o|         [o] }
+							else				Proc.new { |os, o| os << o }
+							end
+							
+						when :'?'
+							case num
+							when :first then	Proc.new { ||  nil }
+							else				Proc.new { |o|   o }
+							end
+							
+						when :elp
+							case num
+							when :first then	Proc.new { ||         [] }
+							else				Proc.new { |prime| prime }
+							end
+							
+						when :nelp
+							case num
+							when :first	then	Proc.new { |el|                                         [el] }
+							when :second	then	Proc.new { |els, _, el|                           els + [el] }
+							else				Proc.new { |*el| if el.length == 1 then el.first else el end }
+							end
+						end,
+						p.rhs.length
+					]
 					
 					@production_precs[p.id] = p.last_terminal
 				end
@@ -163,25 +179,41 @@ module RLTK # :nodoc:
 					
 					@grammar.callback do |p, type, num|
 						@procs[p.id] =
-						[if type == :*
-							if num == :first
-								Proc.new { |v| [] }
-							else
-								Proc.new { |v| [v[0]] + v[1] }
-							end
-						elsif type == :+
-							if num == :first
-								Proc.new { |v| v[0] }
-							else
-								Proc.new { |v| [v[0]] + v[1] }
-							end
-						elsif type == :'?'
-							if num == :first
-								Proc.new { |v| nil }
-							else
-								Proc.new { |v| v[0] }
-							end
-						end, p.rhs.length]
+						[
+							case type
+							when :*
+								case num
+								when :first then	Proc.new { |v|           [] }
+								else				Proc.new { |v| v[0] << v[1] }
+								end
+							
+							when :+
+								case num
+								when :first then	Proc.new { |v|       [v[0]] }
+								else				Proc.new { |v| v[0] << v[1] }
+								end
+							
+							when :'?'
+								case num
+								when :first then	Proc.new { |v|  nil }
+								else				Proc.new { |v| v[0] }
+								end
+							
+							when :elp
+								case num
+								when :first then	Proc.new { |v|   [] }
+								else				Proc.new { |v| v[0] }
+								end
+							
+							when :nelp
+								case num
+								when :first	then	Proc.new { |v|                                        v }
+								when :second	then	Proc.new { |v|                            v[0] + [v[2]] }
+								else				Proc.new { |v| if v.length == 1 then v.first else v end }
+								end
+							end,
+							p.rhs.length
+						]
 						
 						@production_precs[p.id] = p.last_terminal
 					end
@@ -365,6 +397,14 @@ module RLTK # :nodoc:
 				@states.each { |state| state.clean }
 			end
 			
+			# Adds productions and actions for parsing empty lists.
+			#
+			# @see CFG#empty_list_production
+			def empty_list_production(symbol, list_elements, separator)
+				@grammar.empty_list(symbol, list_elements, separator)
+			end
+			alias :empty_list :empty_list_production 
+			
 			# This function will print a description of the parser to the
 			# provided IO object.
 			#
@@ -507,7 +547,9 @@ module RLTK # :nodoc:
 				opts = build_finalize_opts(opts)
 				
 				# Get the name of the file in which the parser is defined.
-				def_file = caller()[2].split(':')[0]
+				#
+				# FIXME: See why this is failing for the simple ListParser example.
+				def_file = caller()[2].split(':')[0] if opts[:use]
 				
 				# Check to make sure we can load the necessary information
 				# from the specified object.
@@ -725,6 +767,14 @@ module RLTK # :nodoc:
 				end
 			end
 			
+			# Adds productions and actions for parsing nonempty lists.
+			#
+			# @see CFG#nonempty_list_production
+			def nonempty_list_production(symbol, list_elements, separator)
+				@grammar.nonempty_list(symbol, list_elements, separator)
+			end
+			alias :nonempty_list :nonempty_list_production 
+			
 			# This function is where actual parsing takes place.  The
 			# _tokens_ argument must be an array of Token objects, the last
 			# of which has type EOS.  By default this method will return the
@@ -772,9 +822,7 @@ module RLTK # :nodoc:
 				tokens.each do |token|
 					# Check to make sure this token was seen in the
 					# grammar definition.
-					if not @symbols.include?(token.type)
-						raise BadToken
-					end
+					raise BadToken if not @symbols.include?(token.type)
 					
 					v.puts("Current token: #{token.type}#{if token.value then "(#{token.value})" end}") if v
 					
@@ -1265,7 +1313,7 @@ module RLTK # :nodoc:
 				@state_stack	<< state
 				@output_stack	<< o
 				@node_stack	<< @labels.length
-				@labels		<< node0
+				@labels		<< if CFG::is_terminal?(node0) and o then node0.to_s + "(#{o})" else node0 end
 				@positions	<< position
 				
 				if CFG::is_nonterminal?(node0)

data/lib/rltk/util/monkeys.rb

@@ -18,6 +18,8 @@
 # @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.
 #
+# @raise [ArgumentError] An error is raise if the type checking fails.
+#
 # @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
@@ -26,9 +28,9 @@ def check_type(o, type, blame = nil, strict = false)
 		o
 	else
 		if blame
-			raise "Parameter #{blame} must be an instance of the #{type.name} class.  Received an instance of #{o.class.name}."
+			raise ArgumentError, "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}."
+			raise ArgumentError, "Expected an object of type #{type.name}.  Received an instance of #{o.class.name}."
 		end
 	end
 end
@@ -40,6 +42,8 @@ end
 # @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.
 #
+# @raise [ArgumentError] An error is raise if the type checking fails.
+#
 # @return [Object] The object passed in parameter o.
 def check_array_type(array, type, blame = nil, strict = false)
 	array.each do |o|
@@ -47,9 +51,9 @@ def check_array_type(array, type, blame = nil, strict = false)
 		
 		if not type_ok
 			if blame
-				raise "Parameter #{blame} must contain instances of the #{type.name} class."
+				raise ArgumentError, "Parameter #{blame} must contain instances of the #{type.name} class."
 			else
-				raise "Expected an object of type #{type.name}."
+				raise ArgumentError, "Expected an object of type #{type.name}."
 			end
 		end
 	end

data/lib/rltk/version.rb

@@ -5,7 +5,7 @@
 
 module RLTK # :nodoc:
 	# The version number of the RLTK library.
-	VERSION			= '2.0.0'
+	VERSION			= '2.1.0'
 	# The version of LLVM targeted by RLTK.
 	LLVM_TARGET_VERSION	= '3.0'
 end

data/test/tc_ast.rb

@@ -29,34 +29,88 @@ class ASTNodeTester < Test::Unit::TestCase
 
 	class DNode < RLTK::ASTNode; end
 	
+	class SNode < RLTK::ASTNode
+		value :string, String
+		
+		child :left, SNode
+		child :right, SNode
+	end
+	
 	def setup
-		@leaf0 = CNode.new(nil, nil)
-		@tree0 = ANode.new(BNode.new(@leaf0, nil), BNode.new(nil, nil))
+		@leaf0 = CNode.new
+		@tree0 = ANode.new(BNode.new(@leaf0), BNode.new)
+		
+		@tree1 = ANode.new(BNode.new(CNode.new), BNode.new)
+		@tree2 = ANode.new(BNode.new, BNode.new(CNode.new))
 		
-		@tree1 = ANode.new(BNode.new(CNode.new(nil, nil), nil), BNode.new(nil, nil))
-		@tree2 = ANode.new(BNode.new(nil, nil), BNode.new(CNode.new(nil, nil), nil))
+		@tree3 =	SNode.new('F',
+					SNode.new('B',
+						SNode.new('A'),
+						SNode.new('D',
+							SNode.new('C'),
+							SNode.new('E')
+						),
+					),
+					SNode.new('G',
+						nil,
+						SNode.new('I',
+							SNode.new('H')
+						)
+					)
+				)
 	end
 	
 	def test_children
-		node = ANode.new(nil, nil)
+		node = ANode.new
 		
 		assert_equal(node.children, [nil, nil])
 		
-		node.children = (expected_children = [BNode.new(nil, nil), CNode.new(nil, nil)])
+		node.children = (expected_children = [BNode.new, CNode.new])
 		
 		assert_equal(node.children, expected_children)
 		
 		node.map do |child|
 			if child.is_a?(BNode)
-				CNode.new(nil, nil)
+				CNode.new
 			else
-				BNode.new(nil, nil)
+				BNode.new
 			end
 		end
 		
 		assert_equal(node.children, expected_children.reverse)
 	end
 	
+	def test_dump
+		tree0_string = @tree0.dump
+		
+		reloaded_tree = Marshal.load(tree0_string)
+		
+		assert_equal(@tree0, reloaded_tree)
+	end
+	
+	def test_each
+		# Test pre-order
+		nodes	= []
+		expected	= ['F', 'B', 'A', 'D', 'C', 'E', 'G', 'I', 'H']
+		@tree3.each(:pre) { |n| nodes << n.string }
+		
+		assert_equal(expected, nodes)
+		
+		# Test post-order
+		nodes	= []
+		expected	= ['A', 'C', 'E', 'D', 'B', 'H', 'I', 'G', 'F']
+		@tree3.each(:post) { |n| nodes << n.string }
+		
+		assert_equal(expected, nodes)
+		
+		# Test level-order
+		nodes	= []
+		expected	= ['F', 'B', 'G', 'A', 'D', 'I', 'C', 'E', 'H']
+		@tree3.each(:level) { |n| nodes << n.string }
+		
+		assert_equal(expected, nodes)
+	end
+	
 	def test_equal
 		assert_equal(@tree0, @tree1)
 		assert_not_equal(@tree0, @tree2)

data/test/tc_parser.rb

@@ -31,6 +31,14 @@ class ParserTester < Test::Unit::TestCase
 		rule(/\s/)
 	end
 	
+	class AlphaLexer < RLTK::Lexer
+		rule(/[A-Za-z]/) { |t| [t.upcase.to_sym, t] }
+		
+		rule(/,/) { :COMMA }
+		
+		rule(/\s/)
+	end
+	
 	class APlusBParser < RLTK::Parser
 		production(:a, 'A+ B') { |a, _| a.length }
 		
@@ -77,6 +85,44 @@ class ParserTester < Test::Unit::TestCase
 		finalize
 	end
 	
+	class EmptyListParser0 < RLTK::Parser
+		empty_list('list', :A, :COMMA)
+		
+		finalize
+	end
+	
+	class EmptyListParser1 < RLTK::Parser
+		array_args
+		
+		empty_list('list', ['A', 'B', 'C D'], :COMMA)
+		
+		finalize
+	end
+	
+	class NonEmptyListParser0 < RLTK::Parser
+		nonempty_list('list', :A, :COMMA)
+		
+		finalize
+	end
+	
+	class NonEmptyListParser1 < RLTK::Parser
+		nonempty_list('list', [:A, :B], :COMMA)
+		
+		finalize
+	end
+	
+	class NonEmptyListParser2 < RLTK::Parser
+		nonempty_list('list', ['A', 'B', 'C D'], :COMMA)
+		
+		finalize
+	end
+	
+	class NonEmptyListParser3 < RLTK::Parser
+		nonempty_list('list', 'A+', :COMMA)
+		
+		finalize
+	end
+	
 	class DummyError1 < StandardError; end
 	class DummyError2 < StandardError; end
 	
@@ -193,6 +239,24 @@ class ParserTester < Test::Unit::TestCase
 		assert_equal(4, AStarBParser.parse(ABLexer.lex('aaaab')))
 	end
 	
+	def test_empty_list
+		####################
+		# EmptyListParser0 #
+		####################
+		
+		expected	= []
+		actual	= EmptyListParser0.parse(AlphaLexer.lex(''))
+		assert_equal(expected, actual)
+		
+		####################
+		# EmptyListParser1 #
+		####################
+		
+		expected	= ['a', 'b', ['c', 'd']]
+		actual	= EmptyListParser1.parse(AlphaLexer.lex('a, b, c d'))
+		assert_equal(expected, actual)
+	end
+	
 	def test_environment
 		actual = RotatingCalc.parse(RLTK::Lexers::Calculator.lex('+ 1 2'))
 		assert_equal(3, actual)
@@ -247,6 +311,79 @@ class ParserTester < Test::Unit::TestCase
 		assert_raise(RLTK::BadToken) { RLTK::Parsers::InfixCalc.parse(RLTK::Lexers::EBNF.lex('A B C')) }
 	end
 	
+	def test_nonempty_list
+		#######################
+		# NonEmptyListParser0 #
+		#######################
+		
+		expected	= ['a']
+		actual	= NonEmptyListParser0.parse(AlphaLexer.lex('a'))
+		assert_equal(expected, actual)
+		
+		expected	= ['a', 'a']
+		actual	= NonEmptyListParser0.parse(AlphaLexer.lex('a, a'))
+		assert_equal(expected, actual)
+		
+		assert_raise(RLTK::NotInLanguage) { NonEmptyListParser0.parse(AlphaLexer.lex(''))   }
+		assert_raise(RLTK::NotInLanguage) { NonEmptyListParser0.parse(AlphaLexer.lex(','))  }
+		assert_raise(RLTK::NotInLanguage) { NonEmptyListParser0.parse(AlphaLexer.lex('aa')) }
+		assert_raise(RLTK::NotInLanguage) { NonEmptyListParser0.parse(AlphaLexer.lex('a,')) }
+		assert_raise(RLTK::NotInLanguage) { NonEmptyListParser0.parse(AlphaLexer.lex(',a')) }
+		
+		#######################
+		# NonEmptyListParser1 #
+		#######################
+		
+		expected	= ['a']
+		actual	= NonEmptyListParser1.parse(AlphaLexer.lex('a'))
+		assert_equal(expected, actual)
+		
+		expected	= ['b']
+		actual	= NonEmptyListParser1.parse(AlphaLexer.lex('b'))
+		assert_equal(expected, actual)
+		
+		expected	= ['a', 'b', 'a', 'b']
+		actual	= NonEmptyListParser1.parse(AlphaLexer.lex('a, b, a, b'))
+		assert_equal(expected, actual)
+		
+		assert_raise(RLTK::NotInLanguage) { NonEmptyListParser1.parse(AlphaLexer.lex('a b')) }
+		
+		#######################
+		# NonEmptyListParser2 #
+		#######################
+		
+		expected	= ['a']
+		actual	= NonEmptyListParser2.parse(AlphaLexer.lex('a'))
+		assert_equal(expected, actual)
+		
+		expected	= ['b']
+		actual	= NonEmptyListParser2.parse(AlphaLexer.lex('b'))
+		assert_equal(expected, actual)
+		
+		expected	= [['c', 'd']]
+		actual	= NonEmptyListParser2.parse(AlphaLexer.lex('c d'))
+		assert_equal(expected, actual)
+		
+		expected	= [['c', 'd'], ['c', 'd']]
+		actual	= NonEmptyListParser2.parse(AlphaLexer.lex('c d, c d'))
+		assert_equal(expected, actual)
+		
+		expected	= ['a', 'b', ['c', 'd']]
+		actual	= NonEmptyListParser2.parse(AlphaLexer.lex('a, b, c d'))
+		assert_equal(expected, actual)
+		
+		assert_raise(RLTK::NotInLanguage) { NonEmptyListParser2.parse(AlphaLexer.lex('c')) }
+		assert_raise(RLTK::NotInLanguage) { NonEmptyListParser2.parse(AlphaLexer.lex('d')) }
+		
+		#######################
+		# NonEmptyListParser3 #
+		#######################
+		
+		expected	= [['a'], ['a', 'a'], ['a', 'a', 'a']]
+		actual	= NonEmptyListParser3.parse(AlphaLexer.lex('a, aa, aaa'))
+		assert_equal(expected, actual)
+	end
+	
 	def test_postfix_calc
 		actual = RLTK::Parsers::PostfixCalc.parse(RLTK::Lexers::Calculator.lex('1 2 +'))
 		assert_equal(3, actual)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rltk
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-07 00:00:00.000000000 Z
+date: 2012-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -192,6 +192,8 @@ files:
 - lib/rltk/cg/value.rb
 - lib/rltk/cg/bindings.rb
 - lib/rltk/cg/llvm.rb
+- lib/rltk/cg/target.rb
+- lib/rltk/cg/triple.rb
 - lib/rltk/cg/generated_bindings.rb
 - lib/rltk/parsers/postfix_calc.rb
 - lib/rltk/parsers/infix_calc.rb