bibtex-ruby 1.2.1 → 1.3.0

data/lib/bibtex/entry.rb

@@ -1,6 +1,6 @@
 #--
 # BibTeX-Ruby
-# Copyright (C) 2010	Sylvester Keil <sylvester.keil.or.at>
+# Copyright (C) 2010-2011	Sylvester Keil <sylvester.keil.or.at>
 # 
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -16,57 +16,80 @@
 # along with this program.	If not, see <http://www.gnu.org/licenses/>.
 #++
 
+require 'forwardable'
+
 module BibTeX
 	#
 	# Represents a regular BibTeX entry.
 	#
 	class Entry < Element
-	  
-		attr_reader :key, :type, :fields
-	 
+	  extend Forwardable	  
+	  include Enumerable
+
 		# Hash containing the required fields of the standard entry types
-		@@RequiredFields = Hash.new([])
-		@@RequiredFields.merge!({
-			:article => [:author,:title,:journal,:year],
-			:book => [[:author,:editor],:title,:publisher,:year],
-			:booklet => [:title],
-			:conference => [:author,:title,:booktitle,:year],
-			:inbook => [[:author,:editor],:title,[:chapter,:pages],:publisher,:year],
-			:incollection => [:author,:title,:booktitle,:publisher,:year],
+		REQUIRED_FIELDS = Hash.new([]).merge({
+			:article       => [:author,:title,:journal,:year],
+			:book          => [[:author,:editor],:title,:publisher,:year],
+			:booklet       => [:title],
+			:conference    => [:author,:title,:booktitle,:year],
+			:inbook        => [[:author,:editor],:title,[:chapter,:pages],:publisher,:year],
+			:incollection  => [:author,:title,:booktitle,:publisher,:year],
 			:inproceedings => [:author,:title,:booktitle,:year],
-			:manual => [:title],
+			:manual        => [:title],
 			:mastersthesis => [:author,:title,:school,:year],
-			:misc => [],
-			:phdthesis => [:author,:title,:school,:year],
-			:proceedings => [:title,:year],
-			:techreport => [:author,:title,:institution,:year],
-			:unpublished => [:author,:title,:note]
-		})
+			:misc          => [],
+			:phdthesis     => [:author,:title,:school,:year],
+			:proceedings   => [:title,:year],
+			:techreport    => [:author,:title,:institution,:year],
+			:unpublished   => [:author,:title,:note]
+		}).freeze
+
+    NAME_FIELDS = [:author, :editor, :translator].freeze
+	  
+		attr_reader :type, :fields
+    def_delegators :@fields, :empty?, :each
 
 		# Creates a new instance. If a hash is given, the entry is populated accordingly.
-		def initialize(hash={})
+		def initialize(attributes = {})
 			@fields = {}
 		  
-		  self.type = hash.delete(:type) if hash.has_key?(:type)
-		  self.key = hash.delete(:key) if hash.has_key?(:key)
-						
-			hash.each { |k, v| add(k.to_sym, v) }
+		  self.type = attributes.delete(:type) if attributes.has_key?(:type)
+		  self.key = attributes.delete(:key) if attributes.has_key?(:key)
+			
+			add(attributes)
 			
 			yield self if block_given?
 		end
 
 		# Sets the key of the entry
 		def key=(key)
-			raise(ArgumentError, "BibTeX::Entry key must be of type String; was: #{key.class.name}.") unless key.is_a?(::String)
-			@key = key
+			raise(ArgumentError, "keys must be convertible to Symbol; was: #{type.class.name}.") unless type.respond_to?(:to_sym)
+
+      unless @bibliography.nil?
+  			@bibliography.entries.delete(@key)
+  			@bibliography.entries[key] = self
+      end
+
+			@key = key.to_sym
+		end
+		
+		def key
+		  @key ||= default_key
 		end
 
+		alias :id :key		
+		alias :id= :key=
+		
 		# Sets the type of the entry.
 		def type=(type)
-			raise(ArgumentError, "BibTeX::Entry type must be convertible to Symbol; was: #{type.class.name}.") unless type.respond_to?(:to_sym)
+			raise(ArgumentError, "types must be convertible to Symbol; was: #{type.class.name}.") unless type.respond_to?(:to_sym)
 			@type = type.to_sym
 		end
 		
+		def has_type?(type)
+      type.to_s.match(/^entry$/i) || @type == type.to_sym || super
+    end
+    
 		def method_missing(name, *args)
 		  return self[name] if @fields.has_key?(name)
 		  return self.send(:add, name.to_s.chop.to_sym, args[0]) if name.to_s.match(/=$/)		  
@@ -77,9 +100,23 @@ module BibTeX
 		  @fields.has_key?(method.to_sym) || method.to_s.match(/=$/) || super
 		end
 		
+		# Renames the given field names unless a field with the new name already
+		# exists.
+		def rename(*arguments)
+		  Hash[*arguments.flatten].each_pair do |from,to|
+		    if @field.has_key?(from) && !@field.has_key?(to)
+		      @field[to] = @field[from]
+		      @field.delete(from)
+	      end
+		  end
+		  self
+		end
+		
+		alias :rename_fields :rename
+		
 		# Returns the value of the field with the given name.
 		def [](name)
-			@fields[name.to_sym].to_s
+			@fields[name.to_sym]
 		end
 
 		# Adds a new field (name-value pair) to the entry.
@@ -88,13 +125,23 @@ module BibTeX
 			add(name.to_sym, value)
 		end
 
-		# Adds a new field (name-value pair) to the entry.
-		# Returns the new value.
-		def add(name, value)
-			raise(ArgumentError, "BibTeX::Entry field name must be of type Symbol; was: #{name.class.name}.") unless name.is_a?(Symbol)
-			raise(ArgumentError, "BibTeX::Entry field value must be of type Array, Symbol, or String; was: #{value.class.name}.") unless [Array,::String,Symbol].map { |k| value.is_a?(k) }.inject { |sum,n| sum || n }
-			@fields[name] = Extensions.string_replacement(value.is_a?(Array) ? value : [value])
+		# Adds a new field (name-value pair) or multiple fields to the entry.
+		# Returns the entry for chainability.
+		#
+		# call-seq:
+		# add(:author, "Edgar A. Poe")
+		# add(:author, "Edgar A. Poe", :title, "The Raven")
+		# add([:author, "Edgar A. Poe", :title, "The Raven"])
+		# add(:author => "Edgar A. Poe", :title => "The Raven")
+		#
+		def add(*arguments)
+		  Hash[*arguments.flatten].each_pair do |name, value|
+			  @fields[name.to_sym] = Value.new(value)
+			end
+			self
 		end
+		
+		alias :<< :add
 
 		# Removes the field with a given name from the entry.
 		# Returns the value of the deleted field; nil if the field was not set.
@@ -102,77 +149,94 @@ module BibTeX
 			@fields.delete(name.to_sym)
 		end
 
-		# Adds all the fields contained in a given hash to the entry.
-		def <<(fields)
-			raise(ArgumentError, "BibTeX::Entry fields must be of type Hash; was: #{fields.class.name}.") unless fields.is_a?(Hash)
-			fields.each { |n,v| add(n,v) }
-			self
-		end
-
-		# Returns true if the entry currently contains no field.
-		def empty?
-			@fields.empty?
-		end
-
 		# Returns false if the entry is one of the standard entry types and does not have
 		# definitions of all the required fields for that type.
 		def valid?
-			!@@RequiredFields[@type].map { |f|
+			REQUIRED_FIELDS[@type].all? do |f|
 				f.is_a?(Array) ? !(f & @fields.keys).empty? : !@fields[f].nil?
-			}.include?(false)
+			end
 		end
 
 		# Called when the element was added to a bibliography.
 		def added_to_bibliography(bibliography)
-			super(bibliography)
-			bibliography.entries[@key] = self
+			super
+			bibliography.entries[key] = self
 			self
 		end
-		
+				
 		# Called when the element was removed from a bibliography.
 		def removed_from_bibliography(bibliography)
-			super(bibliography)
-			bibliography.entries[@key] = nil
+			super
+			bibliography.entries[key] = nil
 			self
 		end
 
-		# Replaces all constants in this entry's field values which are defined in +hash+.
-		def replace!(hash)
-			@fields.keys.each { |k| @fields[k] = @fields[k].replace_strings(hash) }
+		def replace(*arguments)
+		  arguments = bibliography.q('@string') if arguments.empty?
+			@fields.values.each { |v| v.replace(*arguments) }
+			self
 		end
 
-    def join!
-			@fields.keys.each { |k| @fields[k] = @fields[k].join_strings }
+    def join
+			@fields.values.each(&:join)
+      self
     end
 
+    # Parses all name values of the entry. Tries to replace and join the
+    # value prior to parsing.
+    def parse_names
+      NAME_FIELDS.each do |key|
+        if name = @fields[key]
+          name.replace(bibliography.q('@string')) unless bibliography.nil?
+          name.join
+          name = name.to_name
+          @fields[key] = name
+        end
+      end
+      self
+    end
+    
 		# Returns a string of all the entry's fields.
-		def content
-			@fields.keys.map { |k| "#{k} = #{ @fields[k].to_s(:quotes => %w({ })) }" }.join(",\n")
+		def content(options = {})
+			@fields.map { |k,v| "#{k} = #{ @fields[k].to_s(options) }" }.join(",\n")
 		end
 
 		# Returns a string representation of the entry.
-		def to_s
-			["@#{type}{#{key},",content.gsub(/^/,'  '),"}\n"].join("\n")
+		def to_s(options = {})
+		  options[:quotes] ||= %w({ })
+			["@#{type}{#{key},", content(options).gsub(/^/,'  '), "}\n"].join("\n")
 		end
 		
-		def to_hash(options={})
+		def to_hash(options = {})
 		  options[:quotes] ||= %w({ })
-		  @fields.keys.map { |k| { k.to_s => @fields[k].to_s(options) } }.inject({ 'key' => @key, 'type' => @type.to_s }) { |sum,n| sum.merge(n) }
+		  Hash[*([:key, key, :type, type] + @fields.map { |k,v| [k, v.to_s(options)] }.flatten)]
+		end
+
+		def to_citeproc(options = {})
+		  to_hash(options)
 		end
 		
-		def to_xml
-  		xml = REXML::Element.new(@type.to_s)
-  		xml.attributes['key'] = @key
+		def to_xml(options = {})
+		  require 'rexml/document'
+	    
+  		xml = REXML::Element.new(type)
+  		xml.attributes['key'] = key
       @fields.each do |k,v|
         e = REXML::Element.new(k.to_s)
-        e.text = v.to_s
+        e.text = v.to_s(options)
         xml.add_element(e)
       end
       xml
 		end
 		
 		def <=>(other)
-		  self.type != other.type ? self.type <=> other.type : self.key != other.key ? self.key <=> other.key : self.to_s <=> other.to_s
+		  type != other.type ? type <=> other.type : key != other.key ? key <=> other.key : to_s <=> other.to_s
+		end
+		
+		protected
+		
+		def default_key
+		  object_id.to_s.to_sym
 		end
 		
 	end

data/lib/bibtex/extensions.rb

@@ -18,43 +18,8 @@
 
 module BibTeX
 
-  # This module contains functions to manipulate BibTeX string literals.
-  # It is intended to be injected in an Array that represents either the
-  # content of a BibTeX @string or an rvalue of a field in a BibTeX entry.
 	module Extensions
-		
-		def self.string_replacement(obj)
-		  raise(ArgumentError, "StringReplacement should only be injected into instances of Array, not #{obj.class}.") unless obj.is_a?(::Array)
-		  class << obj; include ::BibTeX::Extensions::StringReplacement end
-		  obj
-		end
-		
-		module StringReplacement
-      # Returns a string representation of the literal.
-      def to_s(options={})
-        return '' if self.empty?
-        
-        options[:quotes] ||= [nil,nil]
-        
-        if self.length == 1 && !self[0].is_a?(::Symbol)
-          [options[:quotes][0], self[0], options[:quotes][1]].join
-        else
-          self.map { |s| s.is_a?(::Symbol) ? s.to_s : %Q("#{ s }") }.join(' # ')
-        end
-      end
 
-      # Replaces all string constants which are defined in +hash+.
-      def replace_strings(hash)
-        Extensions.string_replacement(self.map { |s| s.is_a?(::Symbol) && hash.has_key?(s) ? hash[s] : s }.flatten)
-      end
-      
-      # Joins consecutive strings separated by '#'.
-      def join_strings
-        Extensions.string_replacement(self.inject([]) { |a,b|
-          a << (a.last.is_a?(::String) && b.is_a?(::String) ? (a.pop + b) : b )         
-        })
-      end
-    end
 	end
 	
 end

data/lib/bibtex/lexer.rb

@@ -1,6 +1,6 @@
 #--
 # BibTeX-Ruby
-# Copyright (C) 2010	Sylvester Keil <http://sylvester.keil.or.at>
+# Copyright (C) 2010-2011 Sylvester Keil <http://sylvester.keil.or.at>
 # 
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -32,7 +32,7 @@ module BibTeX
 		# Creates a new instance. Possible options and their respective
 		# default values are:
 		#
-		# - :include => [:errors] A list that may contain :meta_comments, and
+		# - :include => [:errors] A list that may contain :meta_content, and
 		#		:errors; depending on whether or not these are present, the respective
 		#		tokens are included in the parse tree.
 		# - :strict => true In strict mode objects can start anywhere; therefore
@@ -40,7 +40,7 @@ module BibTeX
 		#		objects; for a more lenient lexer set to false and objects are
 		#		expected to start after a new line (leading white space is permitted).
 		#
-		def initialize(options={})
+		def initialize(options = {})
 			@options = options
 			@options[:include] ||= [:errors]
 			@options[:strict] = true unless @options.has_key?(:strict)
@@ -90,7 +90,7 @@ module BibTeX
 			[:bibtex,:comment,:string,:preamble,:entry].include?(self.mode)
 		end
 		
-		# Returns true if the lexer is currently parsing meta comments.
+		# Returns true if the lexer is currently parsing meta content.
 		def meta_mode?
 			self.mode == :meta
 		end
@@ -119,8 +119,8 @@ module BibTeX
 			when value[0] == :ERROR
 				@stack.push(value) if @options[:include].include?(:errors)
 				leave_object
-			when value[0] == :META_COMMENT
-				if @options[:include].include?(:meta_comments)
+			when value[0] == :META_CONTENT
+				if @options[:include].include?(:meta_content)
 					value[1] = [value[1], line_number_at(@src.pos)]
 					@stack.push(value)
 				end
@@ -194,10 +194,10 @@ module BibTeX
 		def parse_meta
 			match = self.src.scan_until(@options[:strict] ? /@[\t ]*/o : /(^|\n)[\t ]*@[\t ]*/o)
 			unless self.src.matched.nil?
-				push [:META_COMMENT, match.chop]
+				push [:META_CONTENT, match.chop]
 				enter_object
 			else
-				push [:META_COMMENT,self.src.rest]
+				push [:META_CONTENT,self.src.rest]
 				self.src.terminate
 			end
 		end
@@ -318,7 +318,7 @@ module BibTeX
 		
 		def backtrace(error)
 			trace = []
-			trace.unshift(@stack.pop) until @stack.empty? || (!trace.empty? && [:AT,:META_COMMENT].include?(trace[0][0]))
+			trace.unshift(@stack.pop) until @stack.empty? || (!trace.empty? && [:AT,:META_CONTENT].include?(trace[0][0]))
 			trace << error
 			push [:ERROR,trace]
 		end

data/lib/bibtex/name_parser.output

@@ -0,0 +1,464 @@
+
+
+-------- Grammar --------
+
+rule 1 result: 
+rule 2 result: names
+rule 3 names: name
+rule 4 names: names AND name
+rule 5 name: last
+rule 6 name: u_words last
+rule 7 name: sort COMMA first
+rule 8 sort: u_words
+rule 9 sort: LWORD
+rule 10 sort: von LWORD
+rule 11 sort: von u_words
+rule 12 last: word
+rule 13 last: von LWORD
+rule 14 last: von u_words
+rule 15 first: opt_words
+rule 16 first: opt_words COMMA opt_words
+rule 17 u_words: u_word
+rule 18 u_words: u_words u_word
+rule 19 u_word: UWORD
+rule 20 u_word: PWORD
+rule 21 von: LWORD
+rule 22 von: von u_words LWORD
+rule 23 von: von LWORD
+rule 24 words: word
+rule 25 words: words word
+rule 26 opt_words: 
+rule 27 opt_words: words
+rule 28 word: LWORD
+rule 29 word: UWORD
+rule 30 word: PWORD
+
+------- Symbols -------
+
+**Nonterminals, with rules where they appear
+
+  $start (8)
+    on right: 
+    on left : 
+  result (9)
+    on right: 
+    on left : 1 2
+  names (10)
+    on right: 2 4
+    on left : 3 4
+  name (11)
+    on right: 3 4
+    on left : 5 6 7
+  last (12)
+    on right: 5 6
+    on left : 12 13 14
+  u_words (13)
+    on right: 6 8 11 14 18 22
+    on left : 17 18
+  sort (14)
+    on right: 7
+    on left : 8 9 10 11
+  first (15)
+    on right: 7
+    on left : 15 16
+  von (16)
+    on right: 10 11 13 14 22 23
+    on left : 21 22 23
+  word (17)
+    on right: 12 24 25
+    on left : 28 29 30
+  opt_words (18)
+    on right: 15 16
+    on left : 26 27
+  u_word (19)
+    on right: 17 18
+    on left : 19 20
+  words (20)
+    on right: 25 27
+    on left : 24 25
+
+**Terminals, with rules where they appear
+
+  $end (0) 
+  error (1) 
+  COMMA (2) 7 16
+  UWORD (3) 19 29
+  LWORD (4) 9 10 13 21 22 23 28
+  PWORD (5) 20 30
+  AND (6) 4
+  ERROR (7) 
+
+--------- State ---------
+
+state 0
+
+
+  UWORD         shift, and go to state 11
+  LWORD         shift, and go to state 7
+  PWORD         shift, and go to state 12
+  $default      reduce using rule 1 (result)
+
+  result        go to state 1
+  names         go to state 2
+  name          go to state 3
+  last          go to state 4
+  u_words       go to state 5
+  sort          go to state 6
+  von           go to state 8
+  word          go to state 9
+  u_word        go to state 10
+
+state 1
+
+
+  $end          shift, and go to state 13
+
+
+state 2
+
+   2) result : names _
+   4) names : names _ AND name
+
+  AND           shift, and go to state 14
+  $default      reduce using rule 2 (result)
+
+
+state 3
+
+   3) names : name _
+
+  $default      reduce using rule 3 (names)
+
+
+state 4
+
+   5) name : last _
+
+  $default      reduce using rule 5 (name)
+
+
+state 5
+
+   6) name : u_words _ last
+   8) sort : u_words _
+  18) u_words : u_words _ u_word
+
+  UWORD         shift, and go to state 11
+  LWORD         shift, and go to state 18
+  PWORD         shift, and go to state 12
+  $default      reduce using rule 8 (sort)
+
+  last          go to state 15
+  word          go to state 9
+  von           go to state 16
+  u_word        go to state 17
+
+state 6
+
+   7) name : sort _ COMMA first
+
+  COMMA         shift, and go to state 19
+
+
+state 7
+
+   9) sort : LWORD _
+  21) von : LWORD _
+  28) word : LWORD _
+
+  $end          reduce using rule 28 (word)
+  COMMA         reduce using rule 9 (sort)
+  AND           reduce using rule 28 (word)
+  $default      reduce using rule 21 (von)
+
+
+state 8
+
+  10) sort : von _ LWORD
+  11) sort : von _ u_words
+  13) last : von _ LWORD
+  14) last : von _ u_words
+  22) von : von _ u_words LWORD
+  23) von : von _ LWORD
+
+  UWORD         shift, and go to state 22
+  LWORD         shift, and go to state 20
+  PWORD         shift, and go to state 23
+
+  u_words       go to state 21
+  u_word        go to state 10
+
+state 9
+
+  12) last : word _
+
+  $default      reduce using rule 12 (last)
+
+
+state 10
+
+  17) u_words : u_word _
+
+  $default      reduce using rule 17 (u_words)
+
+
+state 11
+
+  19) u_word : UWORD _
+  29) word : UWORD _
+
+  $end          reduce using rule 29 (word)
+  AND           reduce using rule 29 (word)
+  $default      reduce using rule 19 (u_word)
+
+
+state 12
+
+  20) u_word : PWORD _
+  30) word : PWORD _
+
+  $end          reduce using rule 30 (word)
+  AND           reduce using rule 30 (word)
+  $default      reduce using rule 20 (u_word)
+
+
+state 13
+
+
+  $end          shift, and go to state 24
+
+
+state 14
+
+   4) names : names AND _ name
+
+  UWORD         shift, and go to state 11
+  LWORD         shift, and go to state 7
+  PWORD         shift, and go to state 12
+
+  name          go to state 25
+  last          go to state 4
+  u_words       go to state 5
+  sort          go to state 6
+  von           go to state 8
+  word          go to state 9
+  u_word        go to state 10
+
+state 15
+
+   6) name : u_words last _
+
+  $default      reduce using rule 6 (name)
+
+
+state 16
+
+  13) last : von _ LWORD
+  14) last : von _ u_words
+  22) von : von _ u_words LWORD
+  23) von : von _ LWORD
+
+  UWORD         shift, and go to state 22
+  LWORD         shift, and go to state 26
+  PWORD         shift, and go to state 23
+
+  u_words       go to state 27
+  u_word        go to state 10
+
+state 17
+
+  18) u_words : u_words u_word _
+
+  $default      reduce using rule 18 (u_words)
+
+
+state 18
+
+  21) von : LWORD _
+  28) word : LWORD _
+
+  $end          reduce using rule 28 (word)
+  AND           reduce using rule 28 (word)
+  $default      reduce using rule 21 (von)
+
+
+state 19
+
+   7) name : sort COMMA _ first
+
+  UWORD         shift, and go to state 33
+  LWORD         shift, and go to state 32
+  PWORD         shift, and go to state 34
+  $default      reduce using rule 26 (opt_words)
+
+  first         go to state 28
+  opt_words     go to state 29
+  word          go to state 30
+  words         go to state 31
+
+state 20
+
+  10) sort : von LWORD _
+  13) last : von LWORD _
+  23) von : von LWORD _
+
+  $end          reduce using rule 13 (last)
+  COMMA         reduce using rule 10 (sort)
+  AND           reduce using rule 13 (last)
+  $default      reduce using rule 23 (von)
+
+
+state 21
+
+  11) sort : von u_words _
+  14) last : von u_words _
+  18) u_words : u_words _ u_word
+  22) von : von u_words _ LWORD
+
+  UWORD         shift, and go to state 22
+  LWORD         shift, and go to state 35
+  PWORD         shift, and go to state 23
+  COMMA         reduce using rule 11 (sort)
+  $default      reduce using rule 14 (last)
+
+  u_word        go to state 17
+
+state 22
+
+  19) u_word : UWORD _
+
+  $default      reduce using rule 19 (u_word)
+
+
+state 23
+
+  20) u_word : PWORD _
+
+  $default      reduce using rule 20 (u_word)
+
+
+state 24
+
+
+  $default      accept
+
+
+state 25
+
+   4) names : names AND name _
+
+  $default      reduce using rule 4 (names)
+
+
+state 26
+
+  13) last : von LWORD _
+  23) von : von LWORD _
+
+  $end          reduce using rule 13 (last)
+  AND           reduce using rule 13 (last)
+  $default      reduce using rule 23 (von)
+
+
+state 27
+
+  14) last : von u_words _
+  18) u_words : u_words _ u_word
+  22) von : von u_words _ LWORD
+
+  UWORD         shift, and go to state 22
+  LWORD         shift, and go to state 35
+  PWORD         shift, and go to state 23
+  $default      reduce using rule 14 (last)
+
+  u_word        go to state 17
+
+state 28
+
+   7) name : sort COMMA first _
+
+  $default      reduce using rule 7 (name)
+
+
+state 29
+
+  15) first : opt_words _
+  16) first : opt_words _ COMMA opt_words
+
+  COMMA         shift, and go to state 36
+  $default      reduce using rule 15 (first)
+
+
+state 30
+
+  24) words : word _
+
+  $default      reduce using rule 24 (words)
+
+
+state 31
+
+  25) words : words _ word
+  27) opt_words : words _
+
+  UWORD         shift, and go to state 33
+  LWORD         shift, and go to state 32
+  PWORD         shift, and go to state 34
+  $default      reduce using rule 27 (opt_words)
+
+  word          go to state 37
+
+state 32
+
+  28) word : LWORD _
+
+  $default      reduce using rule 28 (word)
+
+
+state 33
+
+  29) word : UWORD _
+
+  $default      reduce using rule 29 (word)
+
+
+state 34
+
+  30) word : PWORD _
+
+  $default      reduce using rule 30 (word)
+
+
+state 35
+
+  22) von : von u_words LWORD _
+
+  $default      reduce using rule 22 (von)
+
+
+state 36
+
+  16) first : opt_words COMMA _ opt_words
+
+  UWORD         shift, and go to state 33
+  LWORD         shift, and go to state 32
+  PWORD         shift, and go to state 34
+  $default      reduce using rule 26 (opt_words)
+
+  opt_words     go to state 38
+  word          go to state 30
+  words         go to state 31
+
+state 37
+
+  25) words : words word _
+
+  $default      reduce using rule 25 (words)
+
+
+state 38
+
+  16) first : opt_words COMMA opt_words _
+
+  $default      reduce using rule 16 (first)
+