aurum 0.1.0

data/example/expression/expression.rb

@@ -0,0 +1,29 @@
+$:.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'aurum'
+
+class ExpressionGrammar < Aurum::Grammar
+	tokens do
+		ignore string(' ').one_or_more 
+		_number range(?0, ?9).one_or_more
+	end
+	
+	precedences do
+		operator '*', '/'
+		operator '+', '-'
+	end
+	
+	productions do
+		expression expression, '+', expression {expression.value = expression1.value + expression2.value}
+		expression expression, '-', expression {expression.value = expression1.value - expression2.value}
+		expression expression, '*', expression {expression.value = expression1.value * expression2.value}
+		expression expression, '/', expression {expression.value = expression1.value / expression2.value}
+		expression '(', expression, ')'
+		expression _number {expression.value = _number.value.to_i}
+	end
+end
+
+puts ExpressionGrammar.parse_expression('1 + 2').value
+puts ExpressionGrammar.parse_expression('1 + 2 * 3').value
+puts ExpressionGrammar.parse_expression('1 * 2 + 3').value
+puts ExpressionGrammar.parse_expression('1 * (2 + 3)').value
+puts ExpressionGrammar.parse_expression('1 + (2 + 3) * 4').value

data/lib/aurum.rb

@@ -0,0 +1,10 @@
+require 'aurum/lexical_table_generator'
+require 'aurum/parsing_table_generator'
+require 'aurum/engine'
+require 'aurum/grammar'
+
+Enumerable.class_eval do
+    def grep_each condition
+        condition.kind_of?(Proc) ? each {|x| yield x if condition.call x} : each {|x| yield x if eval(condition.to_s)}
+    end
+end

data/lib/aurum/engine.rb

@@ -0,0 +1,173 @@
+module Aurum		
+	IO.class_eval do
+		def get_char
+			char, @pushback_char = @pushback_char ? @pushback_char : self.getc, nil			
+			char > 128 ? char * 128 + self.getc : char 
+		end
+		
+		def pushback char
+			@pushback_char = char
+		end
+	end
+	
+	String.class_eval do
+		def get_char
+			@get_char_index = -1 unless @get_char_index
+		    self[@get_char_index += 1] 
+		end
+		
+		def eof?
+			@get_char_index = -1 unless @get_char_index
+			@get_char_index >= (self.length - 1)
+		end
+		
+		def pushback char
+			@get_char_index -= 1
+		end		
+	end
+	
+	Symbol.class_eval {attr_accessor :value}
+	
+	class Lexer
+		def initialize table, accepts, lexical_states, input
+			@table, @accepts, @lexical_states, @input  = table, accepts, lexical_states, input			 
+			shift_to :initial 
+		end
+		
+		def next_symbol
+			return Aurum::EOF if @input.eof?
+			@recognized, lexeme, @pushback_symbol = @pushback_symbol, '', nil
+			until @recognized
+				next_state, char = @start_state, nil
+				while next_state
+					lexeme << char if char
+					state, char = next_state, @input.get_char
+					next_state = goto state, char 		
+				end				
+				@input.pushback char				
+				if @accepts[state].first == IgnoreAction
+					lexeme = ''
+				else
+					@accepts[state].first.execute self
+				end					 				
+			end
+			@recognized.value = lexeme unless @recognized.value 
+			@recognized			
+		end
+		
+		def pushback symbol
+			@pushback_symbol = symbol
+		end
+		
+		def goto state, input
+			return nil unless input
+			next_state = @table[state].find {|tran| tran.symbols.include?(input)} 
+			next_state ? next_state.destination : nil
+		end
+		
+		def shift_to state
+			@start_state = goto 0, -@lexical_states.index(state)-1
+		end
+		
+		def recognize token
+			@recognized = Aurum::Symbol.new token, true
+		end
+	end		
+	
+	RecognizeTokenAction.class_eval do
+		def execute lexer
+			lexer.recognize token
+		end
+	end
+	
+	ChangeStateAction.class_eval do
+		def execute lexer
+			lexer.shift_to state
+		end
+	end
+	
+	RecognizeTokenAndChangeStateAction.class_eval do
+		def execute lexer
+			lexer.recognize token
+			lexer.shift_to state
+		end
+	end
+	
+	class Parser	
+		def initialize productions, parsing_table
+			@productions, @parsing_table = productions, parsing_table
+		end
+		
+		def parse lexer
+			lookahead, state_stack, symbol_stack, value_stack = lexer.next_symbol, [0], [], []
+			lookahead_shift = 0
+			while (true)
+				state = @parsing_table[state_stack.last]
+				action = state[lookahead]
+				if action.kind_of? ShiftAction
+					state_stack.push action.state
+					symbol_stack.push lookahead unless action.is_lookahead_shift
+					action.is_lookahead_shift ? lookahead_shift += 1 : lookahead = lexer.next_symbol  
+				elsif action.kind_of? ReduceAction
+					handle = @productions[action.handle]
+					lookahead_shift.times { state_stack.pop }					
+					lookahead_shift = 0
+					if action.is_read_reduce
+						state_stack.push state
+						symbol_stack.push lookahead
+						lookahead = lexer.next_symbol
+					end
+					state_stack.slice! -handle.symbols.length..-1
+					symbols = symbol_stack.slice! -handle.symbols.length..-1
+					handle.nonterminal == Aurum::START and return value_stack.pop
+					if handle.action
+						context = {handle.nonterminal.name => [SemanticAttributes.new]}
+						handle.symbols.each_with_index do |symbol, index|
+							context[symbol.name] = [] unless context.has_key? symbol.name
+							context[symbol.name] << (symbol.is_terminal ? symbols[index] : value_stack.pop)
+						end
+						SemanticActionContext.new(context).instance_eval &handle.action
+						value_stack.push context[handle.nonterminal.name][0] if context[handle.nonterminal.name]
+					end
+					goto = @parsing_table[state_stack.last][handle.nonterminal]
+					if goto.kind_of? ShiftAction
+						state_stack.push goto.state
+						symbol_stack.push nil
+					else
+						lexer.pushback lookahead
+						lookahead = handle.nonterminal
+					end
+				else
+					error_recover
+				end
+			end
+		end
+		
+		class SemanticActionContext
+			instance_methods.each { |m| undef_method m unless m =~ /^__/ || m == 'new' || m=='instance_eval'}
+			def initialize hash
+				@hash = hash
+			end
+		
+			def method_missing name, *args
+				name_string = name.to_s
+				index = name_string =~ /\d+/ ? name_string.slice!(/\d+/).to_i : 0
+				@hash[name_string][index] and return @hash[name_string][index]
+				SemanticAttributes.new
+			end
+		end
+		
+		class SemanticAttributes
+			instance_methods.each { |m| undef_method m unless m =~ /^__/ || m == 'new'}
+			def initialize
+				@hash = {}
+			end
+		
+			def method_missing name, *args
+				name_string = name.to_s
+				return @hash[name_string] unless name_string[-1] == 61
+				@hash[name_string.slice(0..-2)] = args.first
+			end
+		end	
+	end	
+end

data/lib/aurum/grammar.rb

@@ -0,0 +1,234 @@
+module Aurum
+    Symbol.class_eval { attr_accessor :action }
+
+    class << nil
+        attr_accessor :action
+    end
+
+    module GrammarDefinition
+        instance_methods.each { |m| undef_method m unless m =~ /^__/ || m == 'new' || m=='instance_eval'}
+
+        def method_missing name, *args, &block
+            name_string = name.to_s
+            symbol =
+            case name_string
+            when /^[a-z]/
+                Aurum::Symbol.new name_string, false
+            when '_'
+                nil
+            when /_.+/
+                Aurum::Symbol.new name_string, true
+            end
+            symbol.action = block if block_given?
+            (args.empty? || name_string == '_') and return symbol
+            symbols = args.map do |sym|
+                case sym
+                when String
+                    Aurum::Symbol.new "$literal_#{sym}", true
+                when Aurum::Symbol
+                    sym
+                end
+            end
+            action = symbols.last.action
+            @definition = {} unless @definition
+            @definition[symbol] = [].to_set unless @definition.has_key? symbol
+            production = Aurum::Production.new symbol, symbols.compact
+            production.action = action if action
+            @definition[symbol] << production
+        end
+    end
+
+    class CharacterClassDefinition    	
+        instance_methods.each { |m| undef_method m unless m =~ /^__/ || m == 'new' || m=='instance_eval'}
+		attr_reader :definitions
+		
+		def initialize
+			@definitions = {}
+		end
+
+        def range a, b
+            a = a[0] if a.kind_of? String
+            b = b[0] if b.kind_of? String
+            CharacterSet::Interval.new(a, b).to_char_set
+        end
+
+        def string a
+            result = CharacterSet.new
+            result << a
+            result            
+        end
+
+        def method_missing name, char_set, &block
+            @definitions[name] = char_set unless @definitions.has_key? name
+        end
+    end
+
+	class LexicalSpecification		
+		instance_methods.each { |m| undef_method m unless m =~ /^__/ || m == 'new' || m=='instance_eval'}
+		attr_reader :definitions, :character_classes
+			
+		def initialize definition = {:initial => {}}, state = :initial 
+			@definitions, @character_classes = definition, CharacterClassDefinition.new
+			@lexical_definition = @definitions[state]
+		end
+			
+		def range a, b
+			Pattern.from_char_set CharacterSet::Interval.new(a, b).to_char_set
+		end
+		
+		def string literal
+			Pattern.from_string literal
+		end
+		
+		def the name
+			Pattern.from_char_set @character_classes.definitions[name] 
+		end
+					
+		def shift_to state, *patterns, &config
+			pattern = __create_pattern ChangeStateAction.new(state), *patterns
+			within state, &config if block_given?
+			pattern
+		end
+		
+		def match *patterns, &action
+			__create_pattern UserDefinedAction.new(action), *patterns
+		end
+		
+		def ignore *patterns
+			__create_pattern IgnoreAction, *patterns
+		end
+		
+		def within *states, &config
+			for state in states
+				@definitions[state] = {} unless @definitions[state] 
+				LexicalSpecification.new(@definitions, state).instance_eval &config								
+			end
+		end
+		
+		def recognize_and_shift_to token, state, *patterns
+			__create_pattern RecognizeTokenAndChangeStateAction.new(token.to_s, state), *patterns
+		end
+			
+		def method_missing name, *patterns, &action
+			__create_pattern RecognizeTokenAction.new(name.to_s), *patterns
+		end
+					
+		def __create_pattern action, *patterns 
+			pattern = Pattern.concat *(patterns.collect {|x| x.kind_of?(Pattern) ? x : Pattern.from_string(x.to_s)})
+			@lexical_definition[pattern] = action
+			pattern 
+		end			
+	end	
+	
+	class OperatorPrecedenceDefinition
+		instance_methods.each { |m| undef_method m unless m =~ /^__/ || m == 'new' || m=='instance_eval'}
+		attr_reader :precedences, :associativities
+		
+		def initialize
+			@precedences, @associativities = [], {:right => [], :left => []}
+		end
+		
+		def operator *operators			
+			operators = operators.collect {|x| __get_symbol x}
+			@precedences << operators.uniq
+		end		
+		
+		def left *operators
+			__associativity :left, *operators
+		end
+		
+		def right *operators
+			__associativity :right, *operators
+		end				
+		
+		def method_missing name
+			Aurum::Symbol.new name.to_s, true
+		end	
+		
+		def __get_symbol operator
+			operator.kind_of?(Aurum::Symbol) ? operator : Aurum::Symbol.new("$literal_#{operator}", true) 
+		end
+		
+		def __associativity direction, *operators
+			for operator in operators
+				symbol = __get_symbol operator
+				@associativities[direction] << symbol unless @associativities[direction].include? symbol 
+			end									
+		end
+	end
+	
+	class ProductionDefinition
+		instance_methods.each { |m| undef_method m unless m =~ /^__/ || m == 'new' || m=='instance_eval'}
+		attr_reader :__definitions, :__literals
+		
+		def initialize
+			@__definitions, @__literals = {}, {}
+		end
+		
+		def method_missing name, *args, &block
+			name_string = name.to_s
+			symbol = case name_string
+				when /^[a-z]/ then Aurum::Symbol.new name_string, false
+				when '_' then nil
+				when /_.+/ then Aurum::Symbol.new name_string, true
+			end
+			symbol.action = block if block_given?
+			(args.empty? || name_string == '_') and return symbol
+			symbols = args.map do |sym|
+				if sym.kind_of? String
+					@__literals[Pattern.from_string(sym)] = RecognizeTokenAction.new "$literal_#{sym}"
+					sym = Aurum::Symbol.new("$literal_#{sym}", true)
+				end 									
+				sym
+			end	
+			@__definitions[symbol] = [].to_set unless @__definitions.has_key? symbol
+			production = Aurum::Production.new symbol, symbols.compact
+			production.action = symbols.last.action if symbols.last.action
+			@__definitions[symbol] << production
+		end			
+	end
+	
+	class Grammar		 			 			
+		def self.character_classes &block
+			@lexical_sepcification = LexicalSpecification.new unless @lexical_sepcification 
+			@lexical_sepcification.character_classes.instance_eval &block
+		end
+		
+		def self.tokens &block
+			@lexical_sepcification = LexicalSpecification.new unless @lexical_sepcification
+			@lexical_sepcification.instance_eval &block
+		end
+		
+		def self.precedences &block
+			@precedences = OperatorPrecedenceDefinition.new unless @precedences
+			@precedences.instance_eval &block
+		end
+		
+		def self.productions &block
+			@productions = ProductionDefinition.new unless @productions
+			@productions.instance_eval &block
+		end
+		
+		def self.lexer input
+			@lexical_sepcification.definitions[:initial].merge!(@productions.__literals)
+			generator = Aurum::LexicalTableGenerator.new @lexical_sepcification.definitions
+			table, accepts = generator.lexical_table
+			Aurum::Lexer.new table, accepts, generator.lexical_states, input			
+		end
+		
+		def self.start_from start_symbol
+			generator = Aurum::ParsingTableGenerator.new @productions.__definitions, @precedences.precedences, @precedences.associativities
+			productions = generator.start_from(Aurum::Symbol.new(start_symbol.to_s, false)).productions
+			table, lookeahead_level = generator.parsing_table
+			Aurum::Parser.new productions, table
+		end
+		
+		def self.method_missing name, input
+			name_string = name.to_s
+			if name_string =~ /^parse_/
+				start_nonterminal = name_string.split(/^parse_/).last
+				self.start_from(start_nonterminal).parse self.lexer(input) 
+			end			
+		end
+	end
+end