puppet 0.9.2

data/lib/puppet/parser/interpreter.rb

@@ -0,0 +1,150 @@
+# The interepreter's job is to convert from a parsed file to the configuration
+# for a given client.  It really doesn't do any work on its own, it just collects
+# and calls out to other objects.
+
+require 'puppet'
+require 'puppet/parser/parser'
+require 'puppet/parser/scope'
+
+
+module Puppet
+    module Parser
+        class Interpreter
+            attr_accessor :ast
+            # just shorten the constant path a bit, using what amounts to an alias
+            AST = Puppet::Parser::AST
+
+            # create our interpreter
+            def initialize(hash)
+                unless hash.include?(:Manifest)
+                    raise Puppet::DevError, "Interpreter was not passed a manifest"
+                end
+
+                @file = hash[:Manifest]
+
+                if hash.include?(:UseNodes)
+                    @usenodes = hash[:UseNodes]
+                else
+                    @usenodes = true
+                end
+
+                # Set it to either the value or nil.  This is currently only used
+                # by the cfengine module.
+                @classes = hash[:Classes] || []
+
+                # Create our parser object
+                parsefiles
+
+                evaluate
+            end
+
+            # evaluate our whole tree
+            def run(client, facts)
+                parsefiles()
+
+                # Really, we should stick multiple names in here
+                # but for now just make a simple array
+                names = [client]
+
+                # if the client name is fully qualied (which is normally will be)
+                # add the short name
+                if client =~ /\./
+                    names << client.sub(/\..+/,'')
+                end
+
+                begin
+                    if @usenodes
+                        unless client
+                            raise Puppet::Error,
+                                "Cannot evaluate nodes with a nil client"
+                        end
+
+                        # We've already evaluated the AST, in this case
+                        retval = @scope.evalnode(names, facts)
+                        return retval
+                    else
+                        # We've already evaluated the AST, in this case
+                        @scope = Puppet::Parser::Scope.new() # no parent scope
+                        @scope.interp = self
+                        @scope.type = "puppet"
+                        @scope.name = "top"
+                        return @scope.evaluate(@ast, facts, @classes)
+                    end
+                    #@ast.evaluate(@scope)
+                rescue Puppet::DevError, Puppet::Error, Puppet::ParseError => except
+                    #Puppet.err "File %s, line %s: %s" %
+                    #    [except.file, except.line, except.message]
+                    if Puppet[:debug]
+                        puts except.stack
+                    end
+                    if Puppet[:debug]
+                        puts caller
+                    end
+                    #exit(1)
+                    raise
+                rescue => except
+                    error = Puppet::DevError.new("%s: %s" %
+                        [except.class, except.message])
+                    error.stack = caller
+                    if Puppet[:debug]
+                        puts caller
+                    end
+                    raise error
+                end
+            end
+
+            def scope
+                return @scope
+            end
+
+            private
+
+            # Evaluate the configuration.  If there aren't any nodes defined, then
+            # this doesn't actually do anything, because we have to evaluate the
+            # entire configuration each time we get a connect.
+            def evaluate
+
+                if @usenodes
+                    @scope = Puppet::Parser::Scope.new() # no parent scope
+                    @scope.name = "top"
+                    @scope.type = "puppet"
+                    @scope.interp = self
+                    Puppet.debug "Nodes defined"
+                    @ast.safeevaluate(@scope)
+                else
+                    Puppet.debug "No nodes defined"
+                    return
+                end
+            end
+
+            def parsefiles
+                if defined? @parser
+                    unless @parser.reparse?
+                        return false
+                    end
+                end
+
+                unless FileTest.exists?(@file)
+                    if @ast
+                        Puppet.warning "Manifest %s has disappeared" % @file
+                        return
+                    else
+                        raise Puppet::Error, "Manifest %s must exist" % @file
+                    end
+                end
+
+                Puppet.info "Reloading files"
+                # should i be creating a new parser each time...?
+                @parser = Puppet::Parser::Parser.new()
+                @parser.file = @file
+                @ast = @parser.parse
+
+                # Reevaluate the config.  This is what actually replaces the
+                # existing scope.
+                evaluate
+            end
+        end
+    end
+end
+
+# $Id: interpreter.rb 746 2005-11-17 21:03:19Z luke $

data/lib/puppet/parser/lexer.rb

@@ -0,0 +1,226 @@
+#!/usr/local/bin/ruby -w
+
+# $Id: lexer.rb 700 2005-09-22 23:24:20Z luke $
+
+# the scanner/lexer
+
+require 'strscan'
+require 'puppet'
+
+
+module Puppet
+    class LexError < RuntimeError; end
+    module Parser
+        #---------------------------------------------------------------
+        class Lexer
+            attr_reader :line, :last, :file
+
+                #%r{\w+} => :WORD,
+            @@tokens = {
+                %r{#.*} => :COMMENT,
+                %r{\[} => :LBRACK,
+                %r{\]} => :RBRACK,
+                %r{\{} => :LBRACE,
+                %r{\}} => :RBRACE,
+                %r{\(} => :LPAREN,
+                %r{\)} => :RPAREN,
+                %r{"} => :DQUOTE,
+                %r{\n} => :RETURN,
+                %r{'} => :SQUOTE,
+                %r{=} => :EQUALS,
+                %r{==} => :ISEQUAL,
+                %r{>=} => :GREATEREQUAL,
+                %r{>} => :GREATERTHAN,
+                %r{<} => :LESSTHAN,
+                %r{<=} => :LESSEQUAL,
+                %r{!=} => :NOTEQUAL,
+                %r{,} => :COMMA,
+                %r{\.} => :DOT,
+                %r{:} => :COLON,
+                %r{;} => :SEMIC,
+                %r{\?} => :QMARK,
+                %r{\\} => :BACKSLASH,
+                %r{=>} => :FARROW,
+                %r{[a-z][-\w]*} => :NAME,
+                %r{[A-Z][-\w]*} => :TYPE,
+                %r{[0-9]+} => :NUMBER,
+                %r{\$\w+} => :VARIABLE
+            }
+
+            @@keywords = {
+                "case" => :CASE,
+                "class" => :CLASS,
+                "default" => :DEFAULT,
+                "define" => :DEFINE,
+                "false" => :BOOLEAN,
+                "host" => :NODE,
+                "import" => :IMPORT,
+                "include" => :INCLUDE,
+                "inherits" => :INHERITS,
+                "node" => :NODE,
+                "true" => :BOOLEAN
+            }
+
+            # scan the whole file
+            # basically just used for testing
+            def fullscan
+                array = []
+
+                self.scan { |token,str|
+                    #Puppet.debug("got token '%s' => '%s'" % [token,str])
+                    if token.nil?
+                        return array
+                    else
+                        array.push([token,str])
+                    end
+                }
+                return array
+            end
+
+            # this is probably pretty damned inefficient...
+            # it'd be nice not to have to load the whole file first...
+            def file=(file)
+                @file = file
+                @line = 1
+                File.open(file) { |of|
+                    str = ""
+                    of.each { |line| str += line }
+                    @scanner = StringScanner.new(str)
+                }
+            end
+
+            def initialize
+                @line = 1
+                @last = ""
+                @scanner = nil
+                @file = nil
+                # AAARRGGGG! okay, regexes in ruby are bloody annoying
+                # no one else has "\n" =~ /\s/
+                @skip = %r{[ \t]+}
+            end
+
+            def rest
+                @scanner.rest
+            end
+
+            # this is the heart of the lexer
+            def scan
+                #Puppet.debug("entering scan")
+                if @scanner.nil?
+                    raise TypeError.new("Invalid or empty string")
+                end
+
+                @scanner.skip(@skip)
+                until @scanner.eos? do
+                    yielded = false
+                    sendbreak = false # gah, this is a nasty hack
+                    stoken = nil
+                    sregex = nil
+                    value = ""
+
+                    # first find out which type of token we've got
+                    @@tokens.each { |regex,token|
+                        # we're just checking, which doesn't advance the scan
+                        # pointer
+                        tmp = @scanner.check(regex)
+                        if tmp.nil?
+                            #puppet.debug("did not match %s to '%s'" %
+                            #    [regex,@scanner.rest])
+                            next
+                        end
+
+                        # find the longest match
+                        if tmp.length > value.length
+                            value = tmp 
+                            stoken = token
+                            sregex = regex
+                        else
+                            # we've already got a longer match
+                            next
+                        end
+                    }
+
+                    # error out if we didn't match anything at all
+                    if stoken.nil?
+                        nword = nil
+                        if @scanner.rest =~ /^(\S+)/
+                            nword = $1
+                        elsif@scanner.rest =~ /^(\s+)/
+                            nword = $1
+                        else
+                            nword = @scanner.rest
+                        end
+                        raise "Could not match '%s'" % nword
+                    end
+
+                    value = @scanner.scan(sregex)
+
+                    if value == ""
+                        raise "Didn't match regex on token %s" % stoken
+                    end
+
+                    # token-specific operations
+                    # if this gets much more complicated, it should
+                    # be moved up to where the tokens themselves are defined
+                    # which will get me about 75% of the way to a lexer generator
+                    case stoken
+                    when :NAME then
+                        wtoken = stoken
+                        # we're looking for keywords here
+                        if @@keywords.include?(value)
+                            wtoken = @@keywords[value]
+                            #Puppet.debug("token '%s'" % wtoken)
+                        end
+                        yield [wtoken,value]
+                        @last = value
+                    when :NUMBER then
+                        yield [:NAME,value]
+                        # just throw comments away
+                    when :COMMENT then
+                        # just throw comments away
+                    when :RETURN then
+                        @line += 1
+                        @scanner.skip(@skip)
+                    when :DQUOTE then
+                        #Puppet.debug("searching '%s' after '%s'" % [self.rest,value])
+                        value = self.slurpstring(value)
+                        yield [:QTEXT,value]
+                        @last = value
+                        #stoken = :QTEXT
+                        #Puppet.debug("got string '%s' => '%s'" % [:QTEXT,value])
+                    else
+                        yield [stoken,value]
+                        @last = value
+                        #Puppet.debug("got token '%s' => '%s'" % [stoken,value])
+                    end
+                    @scanner.skip(@skip)
+                end
+                @scanner = nil
+                yield [false,false]
+            end
+
+            # we've encountered an opening quote...
+            # slurp in the rest of the string and return it
+            def slurpstring(quote)
+                # we search for the next quote that isn't preceded by a
+                # backslash; the caret is there to match empty strings
+                str = @scanner.scan_until(/([^\\]|^)#{quote}/)
+                if str.nil?
+                    raise Puppet::LexError.new("Unclosed quote after '%s' in '%s'" %
+                        [self.last,self.rest])
+                else
+                    str.sub!(/#{quote}$/,"")
+                    str.gsub!(/\\#{quote}/,quote)
+                end
+
+                return str
+            end
+
+            # just parse a string, not a whole file
+            def string=(string)
+                @scanner = StringScanner.new(string)
+            end
+        end
+        #---------------------------------------------------------------
+    end
+end

data/lib/puppet/parser/parser.rb

@@ -0,0 +1,1354 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by racc 1.4.4
+# from racc grammer file "grammar.ra".
+#
+
+require 'racc/parser'
+
+
+require 'puppet'
+require 'puppet/parsedfile'
+require 'puppet/parser/lexer'
+require 'puppet/parser/ast'
+#require 'puppet/parser/interpreter'
+
+module Puppet
+    # this exception class already has a :stack accessor
+    class ParseError < Puppet::Error
+        attr_accessor :line, :file
+    end
+
+    class ImportError < Racc::ParseError; end
+end
+
+Puppet[:typecheck] = true
+Puppet[:paramcheck] = true
+
+
+module Puppet
+
+  module Parser
+
+    class Parser < Racc::Parser
+
+module_eval <<'..end grammar.ra modeval..idd1811897f0', 'grammar.ra', 635
+attr_reader :file
+attr_accessor :files
+
+# Create an AST array out of all of the args
+def aryfy(*args)
+    if args[0].is_a?(AST::ASTArray)
+        result = args.shift
+        args.each { |arg|
+            result.push arg
+        }
+    else
+        result = AST::ASTArray.new(
+            :children => args
+        )
+    end
+
+    return result
+end
+
+def file=(file)
+    unless FileTest.exists?(file)
+        raise Puppet::Error, "Could not find file %s" % file
+    end
+    if @files.detect { |f| f.file == file }
+        raise Puppet::ImportError.new("Import loop detected")
+    else
+        @files << Puppet::ParsedFile.new(file)
+        @lexer.file = file
+    end
+end
+
+def initialize
+    @lexer = Puppet::Parser::Lexer.new()
+    @files = []
+    #if Puppet[:debug]
+    #    @yydebug = true
+    #end
+end
+
+def on_error(token,value,stack)
+    #on '%s' at '%s' in\n'%s'" % [token,value,stack]
+    #error = "line %s: parse error after '%s'" %
+    #    [@lexer.line,@lexer.last]
+    error = "Syntax error at '%s'" % [value]
+
+    #if Puppet[:debug]
+        #puts stack.inspect
+        #puts stack.class
+    #end
+    #if @lexer.file
+    #    error += (" in '%s'" % @lexer.file)
+    #end
+
+    except = Puppet::ParseError.new(error)
+    except.line = @lexer.line
+    if @lexer.file
+        except.file = @lexer.file
+    end
+
+    raise except
+end
+
+# how should I do error handling here?
+def parse
+    begin
+        yyparse(@lexer,:scan)
+    rescue Racc::ParseError => except
+        error = Puppet::ParseError.new(except)
+        error.line = @lexer.line
+        error.file = @lexer.file
+        error.stack = caller
+        raise error
+    rescue Puppet::ParseError => except
+        except.line ||= @lexer.line
+        except.file ||= @lexer.file
+        raise except
+    rescue Puppet::Error => except
+        # and this is a framework error
+        except.line ||= @lexer.line
+        except.file ||= @lexer.file
+        except.stack ||= except.stack
+        #if Puppet[:debug]
+        #    puts except.stack
+        #end
+        raise except
+    rescue Puppet::DevError => except
+        except.line ||= @lexer.line
+        except.file ||= @lexer.file
+        except.stack ||= caller
+        #if Puppet[:debug]
+        #    puts except.stack
+        #end
+        raise except
+    rescue => except
+        error = Puppet::DevError.new(except.message)
+        error.line = @lexer.line
+        error.file = @lexer.file
+        error.stack = caller
+        #if Puppet[:debug]
+        #    puts caller
+        #end
+        raise error
+    end
+end
+
+def reparse?
+    @files.detect { |file|
+        file.changed?
+    }
+end
+
+def string=(string)
+    @lexer.string = string
+end
+
+# $Id: parser.rb 729 2005-10-25 19:49:22Z luke $
+..end grammar.ra modeval..idd1811897f0
+
+##### racc 1.4.4 generates ###
+
+racc_reduce_table = [
+ 0, 0, :racc_error,
+ 1, 41, :_reduce_1,
+ 1, 42, :_reduce_none,
+ 2, 42, :_reduce_3,
+ 1, 43, :_reduce_none,
+ 1, 43, :_reduce_none,
+ 1, 43, :_reduce_none,
+ 1, 43, :_reduce_none,
+ 1, 43, :_reduce_none,
+ 1, 43, :_reduce_none,
+ 1, 43, :_reduce_none,
+ 1, 43, :_reduce_none,
+ 2, 48, :_reduce_12,
+ 1, 52, :_reduce_none,
+ 3, 52, :_reduce_14,
+ 1, 53, :_reduce_none,
+ 1, 53, :_reduce_none,
+ 5, 44, :_reduce_17,
+ 5, 44, :_reduce_18,
+ 5, 44, :_reduce_19,
+ 3, 61, :_reduce_20,
+ 1, 56, :_reduce_none,
+ 3, 56, :_reduce_22,
+ 0, 57, :_reduce_none,
+ 1, 57, :_reduce_none,
+ 1, 54, :_reduce_25,
+ 1, 60, :_reduce_26,
+ 1, 62, :_reduce_none,
+ 1, 62, :_reduce_none,
+ 1, 62, :_reduce_none,
+ 1, 62, :_reduce_none,
+ 1, 62, :_reduce_none,
+ 1, 62, :_reduce_none,
+ 3, 45, :_reduce_33,
+ 0, 58, :_reduce_34,
+ 1, 58, :_reduce_35,
+ 3, 58, :_reduce_36,
+ 3, 67, :_reduce_37,
+ 1, 68, :_reduce_none,
+ 3, 68, :_reduce_39,
+ 1, 66, :_reduce_none,
+ 1, 66, :_reduce_none,
+ 1, 66, :_reduce_none,
+ 1, 66, :_reduce_none,
+ 1, 66, :_reduce_none,
+ 1, 66, :_reduce_none,
+ 1, 66, :_reduce_none,
+ 1, 66, :_reduce_none,
+ 1, 66, :_reduce_none,
+ 1, 63, :_reduce_49,
+ 1, 70, :_reduce_50,
+ 4, 71, :_reduce_51,
+ 5, 46, :_reduce_52,
+ 1, 72, :_reduce_none,
+ 2, 72, :_reduce_54,
+ 5, 73, :_reduce_55,
+ 1, 74, :_reduce_none,
+ 3, 74, :_reduce_57,
+ 3, 64, :_reduce_58,
+ 1, 76, :_reduce_none,
+ 3, 76, :_reduce_60,
+ 1, 78, :_reduce_none,
+ 3, 78, :_reduce_62,
+ 3, 77, :_reduce_63,
+ 1, 75, :_reduce_64,
+ 1, 75, :_reduce_65,
+ 1, 75, :_reduce_66,
+ 1, 75, :_reduce_67,
+ 1, 75, :_reduce_none,
+ 2, 47, :_reduce_69,
+ 6, 49, :_reduce_70,
+ 6, 50, :_reduce_71,
+ 6, 51, :_reduce_72,
+ 1, 81, :_reduce_none,
+ 2, 81, :_reduce_74,
+ 0, 82, :_reduce_75,
+ 1, 79, :_reduce_none,
+ 3, 79, :_reduce_77,
+ 3, 79, :_reduce_78,
+ 1, 83, :_reduce_none,
+ 3, 83, :_reduce_80,
+ 3, 84, :_reduce_81,
+ 1, 84, :_reduce_82,
+ 1, 80, :_reduce_none,
+ 2, 80, :_reduce_84,
+ 1, 55, :_reduce_85,
+ 3, 65, :_reduce_86,
+ 1, 69, :_reduce_none,
+ 1, 69, :_reduce_none,
+ 0, 59, :_reduce_none,
+ 1, 59, :_reduce_90 ]
+
+racc_reduce_n = 91
+
+racc_shift_n = 152
+
+racc_action_table = [
+    88,   123,    88,   118,   144,   130,   101,   102,    88,   117,
+    96,     4,     7,    88,    11,    14,   120,    18,    88,    31,
+    40,     2,     5,    88,     9,   122,    15,     5,    35,   110,
+    35,    86,    87,    86,    87,    90,    35,    90,    55,    86,
+    87,    35,   112,    90,    86,    87,    35,   138,    90,    86,
+    87,    35,   104,    90,    86,    87,    28,    29,    90,    28,
+    29,    28,    29,   106,    65,     4,     7,   114,    11,    14,
+     5,    18,    28,    29,    58,     2,     5,    50,     9,    31,
+    15,    31,    28,    29,    31,    35,    31,     5,     2,     5,
+    35,     2,     5,     2,     5,   100,   104,    31,   146,   101,
+   102,    35,   116,   107,     2,     5,   119,    31,    28,    29,
+    55,    35,    54,    61,     2,     5,     4,     7,   126,    11,
+    14,    50,    18,   128,   151,     5,     2,     5,   108,     9,
+    61,    15,    66,    31,    28,    29,    28,    29,    81,   134,
+     2,    72,     4,     7,    48,    11,    14,   136,    18,    61,
+     5,     5,     2,     5,   147,     9,    65,    15,   141,    31,
+    41,    31,   106,    35,    40,    35,     2,     5,     2,     5,
+    28,    29,     4,     7,    39,    11,    14,    24,    18,    28,
+    29,   148,     2,     5,    69,     9,    23,    15,    61,    52,
+   nil,   nil,   nil,   nil,   nil,    31,   nil,   nil,   nil,    35,
+   nil,   nil,     2,     5,    31,   nil,   nil,   nil,    35,   nil,
+   nil,     2,     5,     4,     7,   nil,    11,    14,   nil,    18,
+   nil,   nil,   nil,     2,     5,   nil,     9,   nil,    15,     4,
+     7,   nil,    11,    14,   nil,    18,   nil,   nil,   nil,     2,
+     5,   nil,     9,   nil,    15,     4,     7,   nil,    11,    14,
+   nil,    18,   nil,   nil,   nil,     2,     5,   nil,     9,   nil,
+    15,     4,     7,   nil,    11,    14,   nil,    18,   nil,   nil,
+   nil,     2,     5,   nil,     9,   nil,    15,     4,     7,   nil,
+    11,    14,   nil,    18,   nil,   nil,   nil,     2,     5,   nil,
+     9,   nil,    15 ]
+
+racc_action_check = [
+   143,    93,    54,    83,   125,   105,   125,   125,    55,    83,
+    55,   107,   107,    91,   107,   107,    91,   107,    96,    66,
+    33,   107,   107,   123,   107,    93,   107,    66,   143,    67,
+    54,   143,   143,    54,    54,   143,    55,    54,    70,    55,
+    55,    91,    71,    55,    91,    91,    96,   115,    91,    96,
+    96,   123,    72,    96,   123,   123,   104,   104,   123,   112,
+   112,   119,   119,    73,    46,   115,   115,    76,   115,   115,
+    46,   115,   126,   126,    38,   115,   115,    38,   115,    15,
+   115,   104,    99,    99,   112,   104,   119,    15,   104,   104,
+   119,   112,   112,   119,   119,    57,    61,   126,   132,    57,
+    57,   126,    82,    63,   126,   126,    85,    99,    50,    50,
+    26,    99,    25,    40,    99,    99,   132,   132,    97,   132,
+   132,    21,   132,   103,   149,    52,   132,   132,    65,   132,
+   106,   132,    43,    50,    28,    28,    58,    58,    51,   111,
+    50,    50,   149,   149,    19,   149,   149,   113,   149,   114,
+    18,   118,   149,   149,   133,   149,    41,   149,   122,    28,
+    14,    58,    62,    28,    12,    58,    28,    28,    58,    58,
+    39,    39,   133,   133,    11,   133,   133,     7,   133,     9,
+     9,   137,   133,   133,    48,   133,     4,   133,   148,    24,
+   nil,   nil,   nil,   nil,   nil,    39,   nil,   nil,   nil,    39,
+   nil,   nil,    39,    39,     9,   nil,   nil,   nil,     9,   nil,
+   nil,     9,     9,     0,     0,   nil,     0,     0,   nil,     0,
+   nil,   nil,   nil,     0,     0,   nil,     0,   nil,     0,   141,
+   141,   nil,   141,   141,   nil,   141,   nil,   nil,   nil,   141,
+   141,   nil,   141,   nil,   141,    81,    81,   nil,    81,    81,
+   nil,    81,   nil,   nil,   nil,    81,    81,   nil,    81,   nil,
+    81,   110,   110,   nil,   110,   110,   nil,   110,   nil,   nil,
+   nil,   110,   110,   nil,   110,   nil,   110,    20,    20,   nil,
+    20,    20,   nil,    20,   nil,   nil,   nil,    20,    20,   nil,
+    20,   nil,    20 ]
+
+racc_action_pointer = [
+   189,   nil,   nil,   nil,   183,   nil,   nil,   142,   nil,   177,
+   nil,   162,   159,   nil,   125,    52,   nil,   nil,   115,   144,
+   253,   116,   nil,   nil,   175,   107,    97,   nil,   132,   nil,
+   nil,   nil,   nil,    15,   nil,   nil,   nil,   nil,    72,   168,
+    78,   127,   nil,   123,   nil,   nil,    35,   nil,   184,   nil,
+   106,   133,    90,   nil,    -1,     5,   nil,    91,   134,   nil,
+   nil,    88,   153,    98,   nil,    93,    -8,    24,   nil,   nil,
+    25,     6,    44,    54,   nil,   nil,    34,   nil,   nil,   nil,
+   nil,   221,    87,    -6,   nil,    94,   nil,   nil,   nil,   nil,
+   nil,    10,   nil,    -8,   nil,   nil,    15,   110,   nil,    80,
+   nil,   nil,   nil,   119,    54,    -1,    95,   -13,   nil,   nil,
+   237,   133,    57,   141,   114,    41,   nil,   nil,   116,    59,
+   nil,   nil,   153,    20,   nil,    -2,    70,   nil,   nil,   nil,
+   nil,   nil,    92,   148,   nil,   nil,   nil,   172,   nil,   nil,
+   nil,   205,   nil,    -3,   nil,   nil,   nil,   nil,   153,   118,
+   nil,   nil ]
+
+racc_action_default = [
+   -91,    -4,   -26,    -5,   -91,   -25,    -6,   -91,    -7,   -91,
+    -8,   -91,   -91,    -9,   -91,   -91,   -10,   -11,   -91,   -91,
+    -1,   -91,    -2,   -69,   -75,   -91,   -46,   -45,   -91,   -49,
+   -43,   -85,   -48,   -42,   -40,   -50,   -44,   -47,   -41,   -91,
+   -34,   -75,   -16,   -12,   -13,   -15,   -75,   -73,   -91,    -3,
+   -34,   -91,   -75,   -76,   -91,   -91,   -38,   -91,   -91,   -33,
+   -35,   -91,   -89,   -91,   -83,   -91,   -91,   -91,   -74,   152,
+   -31,   -23,   -25,   -89,   -29,   -21,   -91,   -27,   -30,   -32,
+   -28,   -91,   -91,   -91,   -79,   -82,   -65,   -64,   -66,   -68,
+   -67,   -91,   -53,   -91,   -56,   -59,   -91,   -91,   -58,   -91,
+   -86,   -87,   -88,   -91,   -91,   -91,   -90,   -91,   -84,   -14,
+   -91,   -91,   -24,   -91,   -34,   -91,   -77,   -78,   -91,   -91,
+   -52,   -54,   -91,   -91,   -61,   -91,   -91,   -39,   -51,   -37,
+   -19,   -36,   -91,   -91,   -17,   -22,   -18,   -20,   -70,   -80,
+   -81,   -91,   -57,   -91,   -60,   -63,   -71,   -72,   -91,   -91,
+   -62,   -55 ]
+
+racc_goto_table = [
+    20,    49,    38,    62,    99,    27,    42,    84,    45,    94,
+   131,    47,    75,    73,    25,    44,    92,   125,    77,    89,
+    89,    38,    78,    79,    27,   105,    63,    53,    95,   111,
+    33,    67,    38,    56,    98,    27,   113,    43,    57,    68,
+    51,    70,    91,    80,    59,    85,    94,    46,    71,    33,
+    83,    38,   131,   121,    27,    82,    89,    42,    19,    45,
+    33,    89,   nil,   103,   nil,   nil,   109,   nil,   nil,   124,
+   nil,    74,   143,   139,   135,   nil,   nil,   137,   142,    33,
+    77,   115,   nil,   nil,    78,    79,   nil,   nil,    89,   nil,
+   nil,   nil,    38,   nil,   nil,    27,    49,    38,   nil,   nil,
+    27,   nil,   nil,    70,   127,    80,   nil,   132,    89,   129,
+   133,    85,    38,    49,    49,    27,   150,   nil,   nil,    38,
+    33,   nil,    27,   nil,   140,    33,   nil,   nil,   nil,   nil,
+    49,   145,   nil,    74,   nil,   nil,   nil,   nil,   nil,   nil,
+    33,   149,   nil,   nil,   nil,   nil,   nil,    33 ]
+
+racc_goto_check = [
+     2,     3,    14,    18,    29,     4,    15,    44,    14,    35,
+    27,    14,    21,    18,    26,    13,    33,    38,    23,    30,
+    30,    14,    24,    25,     4,    19,    40,    42,    37,    17,
+    20,    40,    14,    26,    36,     4,    19,    12,    28,    14,
+    39,    15,    32,    14,    26,    14,    35,    41,    16,    20,
+    43,    14,    27,    33,     4,    42,    30,    15,     1,    14,
+    20,    30,   nil,    26,   nil,   nil,    13,   nil,   nil,    37,
+   nil,    20,    29,    44,    21,   nil,   nil,    18,    35,    20,
+    23,     2,   nil,   nil,    24,    25,   nil,   nil,    30,   nil,
+   nil,   nil,    14,   nil,   nil,     4,     3,    14,   nil,   nil,
+     4,   nil,   nil,    15,    26,    14,   nil,     2,    30,    26,
+     2,    14,    14,     3,     3,     4,    37,   nil,   nil,    14,
+    20,   nil,     4,   nil,    26,    20,   nil,   nil,   nil,   nil,
+     3,    26,   nil,    20,   nil,   nil,   nil,   nil,   nil,   nil,
+    20,     2,   nil,   nil,   nil,   nil,   nil,    20 ]
+
+racc_goto_pointer = [
+   nil,    58,     0,   -19,    -4,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,    22,     0,    -7,    -9,    -2,   -42,   -37,   -37,
+    21,   -38,   nil,   -32,   -28,   -27,     5,   -96,    10,   -53,
+   -35,   nil,   -12,   -38,   nil,   -45,   -21,   -27,   -79,    16,
+   -15,    29,     3,    -2,   -45 ]
+
+racc_goto_default = [
+   nil,   nil,   nil,    22,     1,     3,     6,     8,    10,    13,
+    16,    17,   nil,   nil,    21,    26,   nil,   nil,   nil,   nil,
+    12,   nil,    76,    34,    36,    37,   nil,    60,   nil,   nil,
+    30,    32,   nil,   nil,    93,    97,   nil,   nil,   nil,   nil,
+   nil,   nil,    64,   nil,   nil ]
+
+racc_token_table = {
+ false => 0,
+ Object.new => 1,
+ :LBRACK => 2,
+ :QTEXT => 3,
+ :RBRACK => 4,
+ :LBRACE => 5,
+ :RBRACE => 6,
+ :SYMBOL => 7,
+ :FARROW => 8,
+ :COMMA => 9,
+ :TRUE => 10,
+ :FALSE => 11,
+ :EQUALS => 12,
+ :QMARK => 13,
+ :LPAREN => 14,
+ :RPAREN => 15,
+ :ISEQUAL => 16,
+ :GREATEREQUAL => 17,
+ :GREATERTHAN => 18,
+ :LESSTHAN => 19,
+ :LESSEQUAL => 20,
+ :NOTEQUAL => 21,
+ :IF => 22,
+ :ELSE => 23,
+ :IMPORT => 24,
+ :DEFINE => 25,
+ :ELSIF => 26,
+ :VARIABLE => 27,
+ :CLASS => 28,
+ :INHERITS => 29,
+ :NODE => 30,
+ :BOOLEAN => 31,
+ :DOT => 32,
+ :COLON => 33,
+ :TYPE => 34,
+ :NAME => 35,
+ :SEMIC => 36,
+ :CASE => 37,
+ :DEFAULT => 38,
+ :INCLUDE => 39 }
+
+racc_use_result_var = true
+
+racc_nt_base = 40
+
+Racc_arg = [
+ racc_action_table,
+ racc_action_check,
+ racc_action_default,
+ racc_action_pointer,
+ racc_goto_table,
+ racc_goto_check,
+ racc_goto_default,
+ racc_goto_pointer,
+ racc_nt_base,
+ racc_reduce_table,
+ racc_token_table,
+ racc_shift_n,
+ racc_reduce_n,
+ racc_use_result_var ]
+
+Racc_token_to_s_table = [
+'$end',
+'error',
+'LBRACK',
+'QTEXT',
+'RBRACK',
+'LBRACE',
+'RBRACE',
+'SYMBOL',
+'FARROW',
+'COMMA',
+'TRUE',
+'FALSE',
+'EQUALS',
+'QMARK',
+'LPAREN',
+'RPAREN',
+'ISEQUAL',
+'GREATEREQUAL',
+'GREATERTHAN',
+'LESSTHAN',
+'LESSEQUAL',
+'NOTEQUAL',
+'IF',
+'ELSE',
+'IMPORT',
+'DEFINE',
+'ELSIF',
+'VARIABLE',
+'CLASS',
+'INHERITS',
+'NODE',
+'BOOLEAN',
+'DOT',
+'COLON',
+'TYPE',
+'NAME',
+'SEMIC',
+'CASE',
+'DEFAULT',
+'INCLUDE',
+'$start',
+'program',
+'statements',
+'statement',
+'object',
+'assignment',
+'casestatement',
+'import',
+'include',
+'definition',
+'hostclass',
+'nodedef',
+'classnames',
+'classname',
+'name',
+'variable',
+'objectinstances',
+'endsemi',
+'params',
+'endcomma',
+'type',
+'objectinst',
+'objectname',
+'quotedtext',
+'selector',
+'array',
+'rvalue',
+'param',
+'rvalues',
+'comma',
+'boolean',
+'objectref',
+'caseopts',
+'caseopt',
+'casevalues',
+'selectlhand',
+'svalues',
+'selectval',
+'sintvalues',
+'argumentlist',
+'parent',
+'names',
+'nothing',
+'arguments',
+'argument']
+
+Racc_debug_parser = false
+
+##### racc system variables end #####
+
+ # reduce 0 omitted
+
+module_eval <<'.,.,', 'grammar.ra', 37
+  def _reduce_1( val, _values, result )
+    if val[0].is_a?(AST::ASTArray)
+        result = val[0]
+    else
+        result = AST::ASTArray.new(
+            :line => @lexer.line,
+            :children => [val[0]]
+        )
+    end
+
+    # this is mainly so we can test the parser separately from the
+    # interpreter
+#    if Puppet[:parseonly]
+#        begin
+#            if Puppet[:debug]
+#                puts result.tree(0)
+#            end
+#        rescue NoMethodError => detail
+#            Puppet.err detail
+#            #exit(78)
+#        end
+#        #require 'puppet/parser/interpreter'
+#        #result = Puppet::Server.new(result)
+#    end
+   result
+  end
+.,.,
+
+ # reduce 2 omitted
+
+module_eval <<'.,.,', 'grammar.ra', 51
+  def _reduce_3( val, _values, result )
+    if val[0].is_a?(AST::ASTArray)
+        val[0].push(val[1])
+        result = val[0]
+    else
+        result = AST::ASTArray.new(
+            :file => @lexer.file,
+            :line => @lexer.line,
+            :children => [val[0],val[1]]
+        )
+    end
+   result
+  end
+.,.,
+
+ # reduce 4 omitted
+
+ # reduce 5 omitted
+
+ # reduce 6 omitted
+
+ # reduce 7 omitted
+
+ # reduce 8 omitted
+
+ # reduce 9 omitted
+
+ # reduce 10 omitted
+
+ # reduce 11 omitted
+
+module_eval <<'.,.,', 'grammar.ra', 88
+  def _reduce_12( val, _values, result )
+    classnames = aryfy(val[1])
+
+    klasses = []
+    
+    # Now just iterate over each of the class names and create a new
+    # object instance.  FIXME This should probably eventually include
+    # some kind of checking that the asked-for class is a defined class.
+    classnames.each { |classname|
+        emptyary = AST::ASTArray.new(:children => [])
+        klasses << AST::ObjectDef.new(
+            :pin => "{}",
+            :line => @lexer.line,
+            :file => @lexer.file,
+            :type => classname,
+            :params => emptyary
+        )
+    }
+    result = AST::ASTArray.new(
+        :line => @lexer.line,
+        :file => @lexer.file,
+        :children => klasses
+    )
+   result
+  end
+.,.,
+
+ # reduce 13 omitted
+
+module_eval <<'.,.,', 'grammar.ra', 95
+  def _reduce_14( val, _values, result )
+    result = aryfy(val[0], val[2])
+    result.line = @lexer.line
+    result.file = @lexer.file
+   result
+  end
+.,.,
+
+ # reduce 15 omitted
+
+ # reduce 16 omitted
+
+module_eval <<'.,.,', 'grammar.ra', 129
+  def _reduce_17( val, _values, result )
+    if val[0].is_a?(AST::ASTArray)
+        raise Puppet::ParseError, "Invalid name"
+    end
+    array = val[2]
+    if array.is_a?(AST::ObjectInst)
+        array = [array]
+    end
+    result = AST::ASTArray.new(
+        :line => @lexer.line,
+        :file => @lexer.file
+    )
+    # this iterates across each specified objectinstance
+    array.each { |instance|
+        unless instance.is_a?(AST::ObjectInst)
+            raise Puppet::Dev, "Got something that isn't an instance"
+        end
+        # now, i need to somehow differentiate between those things with
+        # arrays in their names, and normal things
+        result.push AST::ObjectDef.new(
+            :pin => "{}",
+            :line => @lexer.line,
+            :file => @lexer.file,
+            :type => val[0],
+            :name => instance[0],
+            :params => instance[1]
+        )
+    }
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'grammar.ra', 145
+  def _reduce_18( val, _values, result )
+    if val[0].is_a?(AST::ASTArray)
+        Puppet.notice "invalid name"
+        raise Puppet::ParseError, "Invalid name"
+    end
+    # an object but without a name
+    # this cannot be an instance of a library type
+
+    # the objects will autogenerate a name if we don't provide one
+    result = AST::ObjectDef.new(
+        :pin => "{}",
+        :line => @lexer.line,
+        :file => @lexer.file,
+        :type => val[0],
+        :params => val[2]
+    )
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'grammar.ra', 157
+  def _reduce_19( val, _values, result )
+    # a template setting for a type
+    if val[0].is_a?(AST::ASTArray)
+        raise Puppet::ParseError, "Invalid type"
+    end
+    result = AST::TypeDefaults.new(
+        :pin => "{}",
+        :line => @lexer.line,
+        :file => @lexer.file,
+        :type => val[0],
+        :params => val[2]
+    )
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'grammar.ra', 165
+  def _reduce_20( val, _values, result )
+    result = AST::ObjectInst.new(
+        :line => @lexer.line,
+        :file => @lexer.file,
+        :children => [val[0],val[2]]
+    )
+   result
+  end
+.,.,
+
+ # reduce 21 omitted
+
+module_eval <<'.,.,', 'grammar.ra', 179
+  def _reduce_22( val, _values, result )
+    if val[0].is_a?(AST::ObjectInst)
+        result = AST::ASTArray.new(
+            :line => @lexer.line,
+            :file => @lexer.file,
+            :children => [val[0],val[2]]
+        )
+    else
+        val[0].push val[2]
+        result = val[0]
+    end
+   result
+  end
+.,.,
+
+ # reduce 23 omitted
+
+ # reduce 24 omitted
+
+module_eval <<'.,.,', 'grammar.ra', 190
+  def _reduce_25( val, _values, result )
+    result = AST::Name.new(
+        :line => @lexer.line,
+        :file => @lexer.file,
+        :value => val[0]
+    )
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'grammar.ra', 198
+  def _reduce_26( val, _values, result )
+    result = AST::Type.new(
+        :line => @lexer.line,
+        :file => @lexer.file,
+        :value => val[0]
+    )
+   result
+  end
+.,.,
+
+ # reduce 27 omitted
+
+ # reduce 28 omitted
+
+ # reduce 29 omitted
+
+ # reduce 30 omitted
+
+ # reduce 31 omitted
+
+ # reduce 32 omitted
+
+module_eval <<'.,.,', 'grammar.ra', 221
+  def _reduce_33( val, _values, result )
+    # this is distinct from referencing a variable
+    variable = AST::Name.new(
+        :line => @lexer.line,
+        :file => @lexer.file,
+        :value => val[0].sub(/^\$/,'')
+    )
+    result = AST::VarDef.new(
+        :pin => "=",
+        :line => @lexer.line,
+        :file => @lexer.file,
+        :name => variable,
+        :value => val[2]
+    )
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'grammar.ra', 230
+  def _reduce_34( val, _values, result )
+    result = AST::ASTArray.new(
+        :line => @lexer.line,
+        :file => @lexer.file,
+        :children => []
+    )
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'grammar.ra', 230
+  def _reduce_35( val, _values, result )
+ result = val[0]
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'grammar.ra', 243
+  def _reduce_36( val, _values, result )
+    if val[0].is_a?(AST::ASTArray)
+        val[0].push(val[2])
+        result = val[0]
+    else
+        result = AST::ASTArray.new(
+            :line => @lexer.line,
+            :file => @lexer.file,
+            :children => [val[0],val[2]]
+        )
+    end
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'grammar.ra', 258
+  def _reduce_37( val, _values, result )
+    leaf = AST::String.new(
+        :line => @lexer.line,
+        :file => @lexer.file,
+        :value => val[0]
+    )
+    result = AST::ObjectParam.new(
+        :pin => "=>",
+        :line => @lexer.line,
+        :file => @lexer.file,
+        :param => leaf,
+        :value => val[2]
+    )
+   result
+  end
+.,.,
+
+ # reduce 38 omitted
+
+module_eval <<'.,.,', 'grammar.ra', 271
+  def _reduce_39( val, _values, result )
+    if val[0].is_a?(AST::ASTArray)
+        result = val[0].push(val[2])
+    else
+        result = AST::ASTArray.new(
+            :line => @lexer.line,
+            :file => @lexer.file,
+            :children => [val[0],val[2]]
+        )
+    end
+   result
+  end
+.,.,
+
+ # reduce 40 omitted
+
+ # reduce 41 omitted
+
+ # reduce 42 omitted
+
+ # reduce 43 omitted
+
+ # reduce 44 omitted
+
+ # reduce 45 omitted
+
+ # reduce 46 omitted
+
+ # reduce 47 omitted
+
+ # reduce 48 omitted
+
+module_eval <<'.,.,', 'grammar.ra', 289
+  def _reduce_49( val, _values, result )
+    result = AST::String.new(
+        :line => @lexer.line,
+        :file => @lexer.file,
+        :value => val[0]
+    )
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'grammar.ra', 297
+  def _reduce_50( val, _values, result )
+    result = AST::Boolean.new(
+        :line => @lexer.line,
+        :file => @lexer.file,
+        :value => val[0]
+    )
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'grammar.ra', 307
+  def _reduce_51( val, _values, result )
+    result = AST::ObjectRef.new(
+        :pin => '[]',
+        :line => @lexer.line,
+        :file => @lexer.file,
+        :type => val[0],
+        :name => val[2]
+    )
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'grammar.ra', 324
+  def _reduce_52( val, _values, result )
+    options = val[3]
+    unless options.is_a?(AST::ASTArray)
+        options = AST::ASTArray.new(
+            :line => @lexer.line,
+            :file => @lexer.file,
+            :children => [val[3]]
+        )
+    end
+    result = AST::CaseStatement.new(
+        :test => val[1],
+        :options => val[3],
+        :file => @lexer.file,
+        :line => @lexer.line
+    )
+   result
+  end
+.,.,
+
+ # reduce 53 omitted
+
+module_eval <<'.,.,', 'grammar.ra', 338
+  def _reduce_54( val, _values, result )
+    if val[0].is_a?(AST::ASTArray)
+        val[0].push val[1]
+        result = val[0]
+    else
+        result = AST::ASTArray.new(
+            :line => @lexer.line,
+            :file => @lexer.file,
+            :children => [val[0], val[1]]
+        )
+    end
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'grammar.ra', 348
+  def _reduce_55( val, _values, result )
+    result = AST::CaseOpt.new(
+        :pin => ":",
+        :value => val[0],
+        :file => @lexer.file,
+        :line => @lexer.line,
+        :statements => val[3]
+    )
+   result
+  end
+.,.,
+
+ # reduce 56 omitted
+
+module_eval <<'.,.,', 'grammar.ra', 362
+  def _reduce_57( val, _values, result )
+    if val[0].is_a?(AST::ASTArray)
+        val[0].push(val[2])
+        result = val[0]
+    else
+        result = AST::ASTArray.new(
+            :line => @lexer.line,
+            :file => @lexer.file,
+            :children => [val[0],val[2]]
+        )
+    end
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'grammar.ra', 372
+  def _reduce_58( val, _values, result )
+    result = AST::Selector.new(
+        :pin => "?",
+        :line => @lexer.line,
+        :file => @lexer.file,
+        :param => val[0],
+        :values => val[2]
+    )
+   result
+  end
+.,.,
+
+ # reduce 59 omitted
+
+module_eval <<'.,.,', 'grammar.ra', 374
+  def _reduce_60( val, _values, result )
+ result = val[1]
+   result
+  end
+.,.,
+
+ # reduce 61 omitted
+
+module_eval <<'.,.,', 'grammar.ra', 389
+  def _reduce_62( val, _values, result )
+    if val[0].is_a?(AST::ASTArray)
+        val[0].push(val[2])
+        result = val[0]
+    else
+        result = AST::ASTArray.new(
+            :line => @lexer.line,
+            :file => @lexer.file,
+            :children => [val[0],val[2]]
+        )
+    end
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'grammar.ra', 399
+  def _reduce_63( val, _values, result )
+    result = AST::ObjectParam.new(
+        :pin => "=>",
+        :line => @lexer.line,
+        :file => @lexer.file,
+        :param => val[0],
+        :value => val[2]
+    )
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'grammar.ra', 407
+  def _reduce_64( val, _values, result )
+    result = AST::String.new(
+        :line => @lexer.line,
+        :file => @lexer.file,
+        :value => val[0]
+    )
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'grammar.ra', 414
+  def _reduce_65( val, _values, result )
+    result = AST::String.new(
+        :line => @lexer.line,
+        :file => @lexer.file,
+        :value => val[0]
+    )
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'grammar.ra', 421
+  def _reduce_66( val, _values, result )
+    result = AST::String.new(
+        :line => @lexer.line,
+        :file => @lexer.file,
+        :value => val[0]
+    )
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'grammar.ra', 428
+  def _reduce_67( val, _values, result )
+    result = AST::Default.new(
+        :line => @lexer.line,
+        :file => @lexer.file,
+        :value => val[0]
+    )
+   result
+  end
+.,.,
+
+ # reduce 68 omitted
+
+module_eval <<'.,.,', 'grammar.ra', 466
+  def _reduce_69( val, _values, result )
+    # importing files
+    # yuk, i hate keywords
+    # we'll probably have to have some kind of search path eventually
+    # but for now, just use a path relative to the file doing the importing
+    dir = @lexer.file.sub(%r{[^/]+$},'').sub(/\/$/, '')
+    if dir == ""
+        dir = "."
+    end
+    result = AST::ASTArray.new(
+        :file => @lexer.file,
+        :line => @lexer.line
+    )
+    Dir.chdir(dir) {
+        Dir.glob(val[1]).each { |file|
+            parser = Puppet::Parser::Parser.new()
+            parser.files = self.files
+            Puppet.debug("importing '%s'" % file)
+            begin
+                parser.file = File.join(dir, file)
+            rescue Puppet::ImportError
+                Puppet.warning(
+                    "Importing %s would result in an import loop" %
+                        File.join(dir, file)
+                )
+                result = AST::ASTArray.new(
+                    :file => @lexer.file,
+                    :line => @lexer.line
+                )
+                next
+            end
+            # push the results into the main result array
+            result.push parser.parse
+        }
+    }
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'grammar.ra', 476
+  def _reduce_70( val, _values, result )
+    result = AST::CompDef.new(
+        :name => AST::Name.new(:value => val[1], :line => @lexer.line),
+        :args => val[2],
+        :file => @lexer.file,
+        :line => @lexer.line,
+        :code => val[4]
+    )
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'grammar.ra', 492
+  def _reduce_71( val, _values, result )
+        #:args => val[2],
+    args = {
+        :name => AST::Name.new(:value => val[1], :line => @lexer.line),
+        :file => @lexer.file,
+        :line => @lexer.line,
+        :code => val[4]
+    }
+    # It'll be an ASTArray if we didn't get a parent
+    if val[2].is_a?(AST::Name)
+        args[:parentclass] = val[2]
+    end
+    result = AST::ClassDef.new(args)
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'grammar.ra', 512
+  def _reduce_72( val, _values, result )
+    unless val[1].is_a?(AST::ASTArray)
+        val[1] = AST::ASTArray.new(
+            :line => val[1].line,
+            :file => val[1].file,
+            :children => [val[1]]
+        )
+    end
+    args = {
+        :file => @lexer.file,
+        :line => @lexer.line,
+        :names => val[1],
+        :code => val[4]
+    }
+    if val[2].is_a?(AST::Name)
+        args[:parentclass] = val[2]
+    end
+    result = AST::NodeDef.new(args)
+   result
+  end
+.,.,
+
+ # reduce 73 omitted
+
+module_eval <<'.,.,', 'grammar.ra', 526
+  def _reduce_74( val, _values, result )
+    if val[0].is_a?(AST::ASTArray)
+        result = val[0]
+        result.push val[1]
+    else
+        result = AST::ASTArray.new(
+            :line => @lexer.line,
+            :file => @lexer.file,
+            :children => [val[0], val[1]]
+        )
+    end
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'grammar.ra', 534
+  def _reduce_75( val, _values, result )
+    result = AST::ASTArray.new(
+        :line => @lexer.line,
+        :file => @lexer.file,
+        :children => []
+    )
+   result
+  end
+.,.,
+
+ # reduce 76 omitted
+
+module_eval <<'.,.,', 'grammar.ra', 539
+  def _reduce_77( val, _values, result )
+    result = val[1]
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'grammar.ra', 550
+  def _reduce_78( val, _values, result )
+    if val[1].is_a?(AST::ASTArray)
+        result = val[1]
+    else
+        result = AST::ASTArray.new(
+            :line => @lexer.line,
+            :file => @lexer.file,
+            :children => [val[0]]
+        )
+    end
+   result
+  end
+.,.,
+
+ # reduce 79 omitted
+
+module_eval <<'.,.,', 'grammar.ra', 564
+  def _reduce_80( val, _values, result )
+    if val[0].instance_of?(AST::ASTArray)
+        val[0].push(val[2])
+        result = val[0]
+    else
+        result = AST::ASTArray.new(
+            :line => @lexer.line,
+            :file => @lexer.file,
+            :children => [val[0],val[2]]
+        )
+    end
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'grammar.ra', 572
+  def _reduce_81( val, _values, result )
+    result = AST::CompArgument.new(
+        :line => @lexer.line,
+        :file => @lexer.file,
+        :children => [val[0],val[2]]
+    )
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'grammar.ra', 579
+  def _reduce_82( val, _values, result )
+    result = AST::CompArgument.new(
+        :line => @lexer.line,
+        :file => @lexer.file,
+        :children => [val[0]]
+    )
+   result
+  end
+.,.,
+
+ # reduce 83 omitted
+
+module_eval <<'.,.,', 'grammar.ra', 588
+  def _reduce_84( val, _values, result )
+    result = AST::Name.new(
+        :value => val[1],
+        :file => @lexer.file,
+        :line => @lexer.line
+    )
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'grammar.ra', 597
+  def _reduce_85( val, _values, result )
+    name = val[0].sub(/^\$/,'')
+    result = AST::Variable.new(
+        :line => @lexer.line,
+        :file => @lexer.file,
+        :value => name
+    )
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'grammar.ra', 606
+  def _reduce_86( val, _values, result )
+    if val[1].is_a?(AST::ASTArray)
+        result = val[1]
+    else
+        result = AST::ASTArray.new
+        result.push val[1]
+    end
+   result
+  end
+.,.,
+
+ # reduce 87 omitted
+
+ # reduce 88 omitted
+
+ # reduce 89 omitted
+
+module_eval <<'.,.,', 'grammar.ra', 611
+  def _reduce_90( val, _values, result )
+ result = nil
+   result
+  end
+.,.,
+
+ def _reduce_none( val, _values, result )
+  result
+ end
+
+    end   # class Parser
+
+  end   # module Parser
+
+end   # module Puppet