rltk 2.2.1 → 3.0.0

data/lib/rltk/cg/value.rb

@@ -7,8 +7,10 @@
 # Requires #
 ############
 
+# Gems
+require 'filigree/abstract_class'
+
 # Ruby Language Toolkit
-require 'rltk/util/abstract_class'
 require 'rltk/cg/bindings'
 require 'rltk/cg/type'
 
@@ -16,7 +18,7 @@ require 'rltk/cg/type'
 # Classes and Modules #
 #######################
 
-module RLTK::CG # :nodoc:
+module RLTK::CG
 	
 	# This class represents LLVM IR "data", including integer and float
 	# literals, functions, and constant arrays, structs, and vectors.
@@ -50,9 +52,9 @@ module RLTK::CG # :nodoc:
 		#
 		# @param [Type] type Type to cast to.
 		#
-		# @return [ConstExpr]
+		# @return [ConstantExpr]
 		def bitcast(type)
-			ConstExpr.new(Bindings.const_bit_cast(@ptr, check_cg_type(type)))
+			ConstantExpr.new(Bindings.const_bit_cast(@ptr, check_cg_type(type)))
 		end
 		
 		# @return [Boolean] If this value is a constant.
@@ -87,7 +89,7 @@ module RLTK::CG # :nodoc:
 		#
 		# @return [String] *str*
 		def name=(str)
-			returning(str) { Bindings.set_value_name(@ptr, check_type(str, String)) }
+			str.tap { Bindings.set_value_name(@ptr, check_type(str, String)) }
 		end
 		
 		# @return [Boolean] If the value is null or not.
@@ -95,42 +97,27 @@ 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
+		# @return [String]  LLVM IR representation of this value
+		def print
+			Bindings.print_value_to_string(@ptr)
 		end
 		
 		# Truncate a value to a given type.
 		#
 		# @param [Type] type Type to truncate to.
 		#
-		# @return [ConstExpr]
+		# @return [ConstantExpr]
 		def trunc(type)
-			ConstExpr.new(Bindings.const_trunc(check_cg_type(type)))
+			ConstantExpr.new(Bindings.const_trunc(check_cg_type(type)))
 		end
 		
 		# Truncate or bitcast a value to the given type as is appropriate.
 		#
 		# @param [Type] type Type to cast or truncate to.
 		#
-		# @return [ConstExpr]
+		# @return [ConstantExpr]
 		def trunc_or_bitcast(type)
-			ConstExpr.new(Bindings.const_trunc_or_bit_cast(check_cg_type(type)))
+			ConstantExpr.new(Bindings.const_trunc_or_bit_cast(check_cg_type(type)))
 		end
 		
 		# @return [Type] Type of this value.
@@ -147,18 +134,18 @@ module RLTK::CG # :nodoc:
 		#
 		# @param [Type] type Type to extend the value to.
 		#
-		# @return [ConstExpr]
+		# @return [ConstantExpr]
 		def zextend(type)
-			ConstExpr.new(Bindings.const_z_ext(check_cg_type(type)))
+			ConstantExpr.new(Bindings.const_z_ext(check_cg_type(type)))
 		end
 		
 		# Zero extend or bitcast the value to the given type as is appropriate.
 		#
 		# @param [Type] type Type to cast or extend to.
 		#
-		# @return [ConstExpr]
+		# @return [ConstantExpr]
 		def zextend_or_bitcast(type)
-			ConstExpr.new(Bindings.const_z_ext_or_bit_cast(check_cg_type(type)))
+			ConstantExpr.new(Bindings.const_z_ext_or_bit_cast(check_cg_type(type)))
 		end
 		
 		# This class is used to access a {Value Value's} attributes.
@@ -227,7 +214,7 @@ module RLTK::CG # :nodoc:
 	#
 	# @abstract
 	class User < Value
-		include AbstractClass
+		include Filigree::AbstractClass
 		
 		# @return [OperandCollection] Proxy object for accessing a value's operands.
 		def operands
@@ -286,7 +273,7 @@ module RLTK::CG # :nodoc:
 	#
 	# @abstract
 	class Constant < User
-		include AbstractClass
+		include Filigree::AbstractClass
 		
 		# Create a new constant from a pointer or a type.  As a library user
 		# you should never pass a pointer in here as that is only used
@@ -306,11 +293,20 @@ module RLTK::CG # :nodoc:
 			end
 		end
 		
+		# Cast a constant to a given address space
+		#
+		# @param [Type]  type  Type to cast to
+		#
+		# @return [ConstantExpr]
+		def addr_space_cast(type)
+			ConstantExpr.new(Bindings.const_addr_space_cast(@ptr, check_cg_type(type)))
+		end
+		
 		# Bitcast a constant to a given type.
 		#
-		# @param [Type] type
+		# @param [Type]  type  Type to cast to
 		#
-		# @return [ConstExpr]
+		# @return [ConstantExpr]
 		def bitcast_to(type)
 			ConstantExpr.new(Bindings.const_bit_cast(@ptr, check_cg_type(type)))
 		end
@@ -351,7 +347,7 @@ module RLTK::CG # :nodoc:
 		#
 		# @param [FFI::Pointer] ptr
 		def initialize(ptr)
-			@ptr = type_check(ptr, FFI::Pointer, 'ptr')
+			@ptr = check_type(ptr, FFI::Pointer, 'ptr')
 		end
 	end
 	
@@ -374,7 +370,7 @@ module RLTK::CG # :nodoc:
 	#
 	# @abstract
 	class ConstantAggregate < Constant
-		include AbstractClass
+		include Filigree::AbstractClass
 		
 		# Extract values from a constant aggregate value.
 		#
@@ -414,14 +410,19 @@ module RLTK::CG # :nodoc:
 		#
 		# @yieldparam index [Integer] Index of the value in the array.
 		#
-		# @param [Type]				element_type	Type of values in this aggregate.
-		# @param [Array<Value>, Integer]	size_or_values	Number of values or array of values.
-		# @param [Proc]				block		Block evaluated if size is specified.
+		# @param [Type]                   element_type    Type of values in this aggregate.
+		# @param [Array<Value>, Integer]  size_or_values  Number of values or array of values.
+		# @param [Proc]                   block           Block evaluated if size is specified.
 		def initialize(element_type, size_or_values, &block)
-			vals_ptr	= make_ptr_to_elements(size_or_values, &block)
-			@type	= ArrayType.new(element_type = check_cg_type(element_type, Type, 'element_type'))
-			@ptr		= Bindings.const_array(element_type, vals_ptr, vals_ptr.size / vals_ptr.type_size)
+			vals_ptr     = make_ptr_to_elements(size_or_values, &block)
+			element_type = check_cg_type(element_type, Type, 'element_type')
+			@ptr         = Bindings.const_array(element_type, vals_ptr, vals_ptr.size / vals_ptr.type_size)
 		end
+		
+		def size
+			self.type.size
+		end
+		alias :length :size
 	end
 	
 	# A sub-class of {ConstantArray} specifically for holding strings.
@@ -464,7 +465,8 @@ module RLTK::CG # :nodoc:
 			
 			@ptr =
 			if context
-				Bindings.const_struct_in_context(check_type(context, Context, 'context'), vals_ptr, vals_ptr.size / vals_ptr.type_size, packed.to_i)
+				Bindings.const_struct_in_context(check_type(context, Context, 'context'),
+				                                 vals_ptr, vals_ptr.size / vals_ptr.type_size, packed.to_i)
 			else
 				Bindings.const_struct(vals_ptr, vals_ptr.size / vals_ptr.type_size, packed.to_i)
 			end
@@ -498,17 +500,17 @@ module RLTK::CG # :nodoc:
 		
 		# @param [Integer] index Index of desired element.
 		#
-		# @return [ConstExpr] Extracted element.
+		# @return [ConstantExpr] Extracted element.
 		def extract_element(index)
-			ConstExpr.new(Bindings.const_extract_element(@ptr, index))
+			ConstantExpr.new(Bindings.const_extract_element(@ptr, index))
 		end
 		
 		# @param [Value]	element	Value to insert into the vector.
 		# @param [Integer]	index	Index to insert the value at.
 		#
-		# @return [ConstExpr] New vector representation with inserted value.
+		# @return [ConstantExpr] New vector representation with inserted value.
 		def insert_element(element, index)
-			ConstExpr.new(Bindings.const_insert_element(@ptr, element, index))
+			ConstantExpr.new(Bindings.const_insert_element(@ptr, element, index))
 		end
 		
 		# @param [ConstantVector] other	Other vector to shuffle with this one.
@@ -518,13 +520,18 @@ module RLTK::CG # :nodoc:
 		def shuffle(other, mask)
 			ConstantVector.new(Bindings.const_shuffle_vector(@ptr, other, mask))
 		end
+		
+		def size
+			self.type.size
+		end
+		alias :length :size
 	end
 	
 	# All number constants inherit from this class.
 	#
 	# @abstract
 	class ConstantNumber < Constant
-		include AbstractClass
+		include Filigree::AbstractClass
 		
 		# @return [Type] The corresponding Type sub-class that is used to represent the type of this value.
 		def self.type
@@ -541,7 +548,7 @@ module RLTK::CG # :nodoc:
 	#
 	# @abstract
 	class ConstantInteger < ConstantNumber
-		include AbstractClass
+		include Filigree::AbstractClass
 		
 		# @return [Boolean] If the integer is signed or not.
 		attr_reader :signed
@@ -560,9 +567,10 @@ module RLTK::CG # :nodoc:
 		# @example Constant integer of all 1s:
 		#   Int32.new
 		#
-		# @param [FFI::Pointer, Integer, String, nil]	overloaded0	Pointer to a ConstantInteger, value, or string representing value.
-		# @param [Boolean, Integer]					overloaded1	Signed or unsigned (when overloaded0 is Integer) or base used to decode string value.
-		# @param [Integer]							size			Optional length of string to use.
+		# @param [FFI::Pointer, Integer, String, nil]  overloaded0  Pointer to a ConstantInteger, value, or string representing value.
+		# @param [Boolean, Integer]                    overloaded1  Signed or unsigned (when overloaded0 is Integer) or base used to
+		#    decode string value.
+		# @param [Integer]                             size         Optional length of string to use.
 		def initialize(overloaded0 = nil, overloaded1 = nil, size = nil)
 			@ptr =
 			case overloaded0
@@ -925,7 +933,7 @@ module RLTK::CG # :nodoc:
 	#
 	# @abstract
 	class ConstantReal < ConstantNumber
-		include AbstractClass
+		include Filigree::AbstractClass
 		
 		# Create a constant real number using a Ruby value or a string.
 		#
@@ -1046,16 +1054,18 @@ module RLTK::CG # :nodoc:
 		end
 	end
 	
+	# A 16-bit floating point number value.
+	class Half     < ConstantReal; end
 	# A double precision floating point number value.
-	class Double	< ConstantReal; end
-	# A single precision floating point number type.
-	class Float	< ConstantReal; end
-	# A 128 bit (16 byte) floating point number type.
-	class FP128	< ConstantReal; end
-	# A 128 bit (16 byte) floating point number type for the PPC architecture.
-	class PPCFP128	< ConstantReal; end
-	# A 80 bit (10 byte) floating point number type for the x86 architecture.
-	class X86FP80	< ConstantReal; end
+	class Double   < ConstantReal; end
+	# A single precision floating point number value.
+	class Float    < ConstantReal; end
+	# A 128 bit (16 byte) floating point number value.
+	class FP128    < ConstantReal; end
+	# A 128 bit (16 byte) floating point number value for the PPC architecture.
+	class PPCFP128 < ConstantReal; end
+	# A 80 bit (10 byte) floating point number value for the x86 architecture.
+	class X86FP80  < ConstantReal; end
 	
 	# This class represents global constants, variables, and functions.
 	class GlobalValue < Constant
@@ -1090,6 +1100,22 @@ module RLTK::CG # :nodoc:
 			Bindings.is_declaration(@ptr).to_bool
 		end
 		
+		# Sets the externally initialized property of a global value.
+		#
+		# @param [Boolean]  bool  If the value is externally initialized
+		#
+		# @return [void]
+		def externally_initialized=(bool)
+			Bindings.set_externally_initialized(@ptr, bool.to_i)
+		end
+		
+		# Check if this global is initialized externally.
+		#
+		# @return [Boolean]
+		def externally_initialized?
+			Bindings.externally_initialized(@ptr).to_bool
+		end
+		
 		# Check if this value is a global constant.
 		#
 		# @return [Boolean]
@@ -1158,6 +1184,23 @@ module RLTK::CG # :nodoc:
 			Bindings.set_section(@ptr, section)
 		end
 		
+		# Returns the thread local model used by a global value. 
+		#
+		# @return [Symbol from _enum_thread_local_mode_]
+		def thread_local_mode
+			Bindings.get_thread_local_mode(@ptr)
+		end 
+		
+		
+		# Set the global value's thread local mode.
+		#
+		# @param [Symbol from _enum_thread_local_mode_] mode
+		#
+		# @return [void]
+		def thread_local_mode=(mode)
+			Bindings.set_thread_local_mode(@ptr, mode)
+		end
+		
 		# Get this value's visibility.
 		#
 		# @see Bindings._enum_visibility_
@@ -1225,7 +1268,5 @@ def make_ptr_to_elements(size_or_values, &block)
 		size_or_values
 	end
 	
-	returning(FFI::MemoryPointer.new(:pointer, values.size)) do |ptr|
-		ptr.write_array_of_pointer(values)
-	end
+	FFI::MemoryPointer.new(:pointer, values.size).write_array_of_pointer(values)
 end

data/lib/rltk/cg.rb

@@ -8,26 +8,25 @@
 # Classes and Modules #
 #######################
 
-module RLTK # :nodoc:
-	
+module RLTK
 	# This module contains classes and methods for code generation.  Code
 	# generation functionality is provided by bindings to
 	# [LLVM](http://llvm.org).
 	module CG
-		autoload :BasicBlock,		'rltk/cg/basic_block'
-		autoload :Bindings,			'rltk/cg/bindings'
-		autoload :Builder,			'rltk/cg/builder'
-		autoload :Context,			'rltk/cg/context'
-		autoload :ExecutionEngine,	'rltk/cg/execution_engine'
-		autoload :Function,			'rltk/cg/function'
-		autoload :GenericValue,		'rltk/cg/generic_value'
-		autoload :Instruction,		'rltk/cg/instruction'
-		autoload :LLVM,			'rltk/cg/llvm'
-		autoload :MemoryBuffer,		'rltk/cg/memory_buffer'
-		autoload :Module,			'rltk/cg/module'
-		autoload :PassManager,		'rltk/cg/pass_manager'
-		autoload :Support,			'rltk/cg/support'
-		autoload :Type,			'rltk/cg/type'
-		autoload :Value,			'rltk/cg/value'
+		autoload :BasicBlock,      'rltk/cg/basic_block'
+		autoload :Bindings,        'rltk/cg/bindings'
+		autoload :Builder,         'rltk/cg/builder'
+		autoload :Context,         'rltk/cg/context'
+		autoload :ExecutionEngine, 'rltk/cg/execution_engine'
+		autoload :Function,        'rltk/cg/function'
+		autoload :GenericValue,    'rltk/cg/generic_value'
+		autoload :Instruction,     'rltk/cg/instruction'
+		autoload :LLVM,            'rltk/cg/llvm'
+		autoload :MemoryBuffer,    'rltk/cg/memory_buffer'
+		autoload :Module,          'rltk/cg/module'
+		autoload :PassManager,     'rltk/cg/pass_manager'
+		autoload :Support,         'rltk/cg/support'
+		autoload :Type,            'rltk/cg/type'
+		autoload :Value,           'rltk/cg/value'
 	end
 end

data/lib/rltk/lexer.rb

@@ -17,11 +17,21 @@ require 'rltk/token'
 # Classes and Modules #
 #######################
 
-module RLTK # :nodoc:
-	
+module RLTK
 	# A LexingError exception is raised when an input stream contains a
 	# substring that isn't matched by any of a lexer's rules.
 	class LexingError < StandardError
+		# @return [Integer]
+		attr_reader :stream_offset
+
+		# @return [Integer]
+		attr_reader :line_number
+
+		# @return [Integer]
+		attr_reader :line_offset
+
+		# @return [String]
+		attr_reader :remainder
 		
 		# @param [Integer]	stream_offset	Offset from begnning of string.
 		# @param [Integer]	line_number	Number of newlines encountered so far.
@@ -55,6 +65,14 @@ module RLTK # :nodoc:
 			# @return [Symbol] State in which the lexer starts.
 			attr_reader :start_state
 			
+			# Called when the Lexer class is sub-classed, it installes
+			# necessary instance class variables.
+			#
+			# @return [void]
+			def inherited(klass)
+				klass.install_icvars
+			end
+			
 			# Installs instance class varialbes into a class.
 			#
 			# @return [void]
@@ -63,14 +81,6 @@ module RLTK # :nodoc:
 				@rules		= Hash.new {|h,k| h[k] = Array.new}
 				@start_state	= :default
 			end
-			
-			# Called when the Lexer class is sub-classed, it installes
-			# necessary instance class variables.
-			#
-			# @return [void]
-			def inherited(klass)
-				klass.install_icvars
-			end
 		
 			# Lex *string*, using *env* as the environment.  This method will
 			# return the array of tokens generated by the lexer with a token
@@ -137,7 +147,7 @@ module RLTK # :nodoc:
 							line_offset += txt.length()
 						end
 					else
-						error = LexingError.new(stream_offset, line_number, line_offset, scanner.post_match)
+						error = LexingError.new(stream_offset, line_number, line_offset, scanner.rest)
 						raise(error, 'Unable to match string with any of the given rules')
 					end
 				end

data/lib/rltk/lexers/calculator.rb

@@ -14,7 +14,7 @@ require 'rltk/lexer'
 # Classes and Modules #
 #######################
 
-module RLTK  # :nodoc:
+module RLTK
 	
 	# The RLTK::Lexers module contains the lexers that are included as part of
 	# the RLKT project.

data/lib/rltk/lexers/ebnf.rb

@@ -14,8 +14,8 @@ require 'rltk/lexer'
 # Classes and Modules #
 #######################
 
-module RLTK # :nodoc:
-	module Lexers # :nodoc:
+module RLTK
+	module Lexers
 		
 		# The EBNF lexer is used by the RLTK::CFG class.
 		class EBNF < Lexer
@@ -24,12 +24,13 @@ module RLTK # :nodoc:
 			# Default State #
 			#################
 			
-			rule(/\*/)	{ :*   }
-			rule(/\+/)	{ :+   }
-			rule(/\?/)	{ :'?' }
+			rule(/\*/) { :STAR     }
+			rule(/\+/) { :PLUS     }
+			rule(/\?/) { :QUESTION }
+			rule(/\./) { :DOT      }
 			
-			rule(/[a-z0-9_]+/)	{ |t| [:NONTERM, t.to_sym] }
-			rule(/[A-Z0-9_]+/)	{ |t| [:TERM,    t.to_sym] }
+			rule(/[a-z0-9_']+/) { |t| [:NONTERM, t.to_sym] }
+			rule(/[A-Z0-9_']+/) { |t| [:TERM,    t.to_sym] }
 			
 			rule(/\s/)
 		end