path: root/lib/puppet/parser/parser.rb

#
# DO NOT MODIFY!!!!
# This file is automatically generated by racc 1.4.5
# from racc grammer file "grammar.ra".
#

require 'racc/parser'


require 'puppet'
require 'puppet/loadedfile'
require 'puppet/parser/lexer'
require 'puppet/parser/ast'
#require 'puppet/parser/interpreter'

module Puppet
    class ParseError < Puppet::Error; 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..idee2a7240ef', 'grammar.ra', 635
require 'puppet/parser/functions'

attr_reader :file, :interp
attr_accessor :files

# Add context to a message; useful for error messages and such.
def addcontext(message, obj = nil)
    obj ||= @lexer

    message += " on line %s" % obj.line
    if file = obj.file
        message += " in file %s" % file
    end

    return message
end

# Create an AST array out of all of the args
def aryfy(*args)
    if args[0].instance_of?(AST::ASTArray)
        result = args.shift
        args.each { |arg|
            result.push arg
        }
    else
        result = ast AST::ASTArray, :children => args
    end

    return result
end

# Create an AST object, and automatically add the file and line information if
# available.
def ast(klass, hash = nil)
    hash ||= {}
    unless hash[:line]
        hash[:line] = @lexer.line
    end

    unless hash[:file]
        if file = @lexer.file
            hash[:file] = file
        end
    end

    return klass.new(hash)
end

# Raise a Parse error.
def error(message)
    except = Puppet::ParseError.new(message)
    except.line = @lexer.line
    if @lexer.file
        except.file = @lexer.file
    end

    raise except
end

def file=(file)
    unless FileTest.exists?(file)
        unless file =~ /\.pp$/
            file = file + ".pp"
        end
        unless FileTest.exists?(file)
            raise Puppet::Error, "Could not find file %s" % file
        end
    end
    if @files.detect { |f| f.file == file }
        raise Puppet::ImportError.new("Import loop detected")
    else
        @files << Puppet::LoadedFile.new(file)
        @lexer.file = file
    end
end

def initialize(interpreter)
    @interp = interpreter
    initvars()
end

# Initialize or reset all of our variables.
def initvars
    @lexer = Puppet::Parser::Lexer.new()
    @files = []
end

# The fully qualifed name, with the full namespace.
def fqname(name)
    [@lexer.namespace, name].join("::").sub(/^::/, '')
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]

    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(string = nil)
    if string
        self.string = string
    end
    begin
        main = yyparse(@lexer,:scan)
    rescue Racc::ParseError => except
        error = Puppet::ParseError.new(except)
        error.line = @lexer.line
        error.file = @lexer.file
        error.set_backtrace except.backtrace
        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
        raise except
    rescue Puppet::DevError => except
        except.line ||= @lexer.line
        except.file ||= @lexer.file
        raise except
    rescue => except
        error = Puppet::DevError.new(except.message)
        error.line = @lexer.line
        error.file = @lexer.file
        error.set_backtrace except.backtrace
        raise error
    end
    if main
        # Store the results as the top-level class.
        interp.newclass("", :code => main)
        return main
    end
ensure
    @lexer.clear
end

# See if any of the files have changed.
def reparse?
    if file = @files.detect { |file| file.changed?  }
        return file.stamp
    else
        return false
    end
end

def string=(string)
    @lexer.string = string
end

# Make emacs happy
# Local Variables:
# mode: ruby
# End:

# $Id$

..end grammar.ra modeval..idee2a7240ef

##### racc 1.4.5 generates ###

racc_reduce_table = [
 0, 0, :racc_error,
 1, 51, :_reduce_1,
 1, 51, :_reduce_none,
 1, 52, :_reduce_none,
 2, 52, :_reduce_4,
 1, 54, :_reduce_none,
 1, 54, :_reduce_none,
 1, 54, :_reduce_none,
 1, 54, :_reduce_none,
 1, 54, :_reduce_none,
 1, 54, :_reduce_none,
 1, 54, :_reduce_none,
 1, 54, :_reduce_none,
 1, 54, :_reduce_none,
 1, 54, :_reduce_none,
 1, 54, :_reduce_none,
 1, 54, :_reduce_none,
 4, 62, :_reduce_17,
 2, 62, :_reduce_18,
 1, 67, :_reduce_none,
 1, 67, :_reduce_none,
 1, 68, :_reduce_none,
 3, 68, :_reduce_22,
 1, 70, :_reduce_none,
 1, 70, :_reduce_none,
 1, 70, :_reduce_none,
 1, 69, :_reduce_none,
 3, 69, :_reduce_27,
 5, 55, :_reduce_28,
 5, 55, :_reduce_29,
 5, 55, :_reduce_30,
 4, 66, :_reduce_31,
 2, 56, :_reduce_32,
 1, 79, :_reduce_33,
 2, 79, :_reduce_34,
 2, 57, :_reduce_35,
 1, 80, :_reduce_none,
 1, 80, :_reduce_none,
 3, 81, :_reduce_38,
 3, 81, :_reduce_39,
 1, 82, :_reduce_none,
 1, 82, :_reduce_none,
 3, 82, :_reduce_42,
 1, 83, :_reduce_none,
 3, 83, :_reduce_44,
 1, 84, :_reduce_none,
 1, 84, :_reduce_none,
 3, 85, :_reduce_47,
 3, 85, :_reduce_48,
 1, 86, :_reduce_none,
 1, 86, :_reduce_none,
 4, 88, :_reduce_51,
 1, 75, :_reduce_none,
 3, 75, :_reduce_53,
 0, 76, :_reduce_none,
 1, 76, :_reduce_none,
 1, 71, :_reduce_56,
 1, 90, :_reduce_57,
 1, 89, :_reduce_none,
 1, 89, :_reduce_none,
 1, 89, :_reduce_none,
 1, 89, :_reduce_none,
 1, 89, :_reduce_none,
 1, 89, :_reduce_none,
 3, 58, :_reduce_64,
 0, 77, :_reduce_65,
 1, 77, :_reduce_66,
 3, 77, :_reduce_67,
 3, 94, :_reduce_68,
 1, 95, :_reduce_none,
 3, 95, :_reduce_70,
 1, 87, :_reduce_none,
 1, 87, :_reduce_none,
 1, 87, :_reduce_none,
 1, 87, :_reduce_none,
 1, 87, :_reduce_none,
 1, 87, :_reduce_none,
 1, 93, :_reduce_none,
 1, 93, :_reduce_none,
 1, 93, :_reduce_none,
 1, 93, :_reduce_none,
 1, 93, :_reduce_none,
 1, 93, :_reduce_none,
 1, 93, :_reduce_none,
 1, 93, :_reduce_none,
 1, 93, :_reduce_none,
 4, 98, :_reduce_86,
 1, 73, :_reduce_87,
 1, 73, :_reduce_88,
 1, 97, :_reduce_89,
 4, 74, :_reduce_90,
 4, 74, :_reduce_91,
 6, 60, :_reduce_92,
 0, 100, :_reduce_none,
 4, 100, :_reduce_94,
 1, 99, :_reduce_none,
 5, 59, :_reduce_96,
 1, 101, :_reduce_none,
 2, 101, :_reduce_98,
 5, 102, :_reduce_99,
 4, 102, :_reduce_100,
 1, 103, :_reduce_none,
 3, 103, :_reduce_102,
 3, 91, :_reduce_103,
 1, 105, :_reduce_none,
 3, 105, :_reduce_105,
 1, 107, :_reduce_none,
 3, 107, :_reduce_107,
 3, 106, :_reduce_108,
 1, 104, :_reduce_none,
 1, 104, :_reduce_none,
 1, 104, :_reduce_none,
 1, 104, :_reduce_none,
 1, 104, :_reduce_none,
 1, 104, :_reduce_none,
 1, 104, :_reduce_115,
 2, 61, :_reduce_116,
 6, 63, :_reduce_117,
 5, 63, :_reduce_118,
 6, 64, :_reduce_119,
 5, 64, :_reduce_120,
 6, 65, :_reduce_121,
 5, 65, :_reduce_122,
 1, 108, :_reduce_none,
 1, 108, :_reduce_none,
 1, 111, :_reduce_none,
 3, 111, :_reduce_126,
 1, 112, :_reduce_none,
 1, 112, :_reduce_none,
 1, 112, :_reduce_none,
 0, 53, :_reduce_130,
 0, 113, :_reduce_131,
 1, 109, :_reduce_none,
 3, 109, :_reduce_133,
 3, 109, :_reduce_134,
 1, 114, :_reduce_none,
 3, 114, :_reduce_136,
 3, 115, :_reduce_137,
 1, 115, :_reduce_138,
 3, 115, :_reduce_139,
 1, 115, :_reduce_140,
 1, 110, :_reduce_none,
 2, 110, :_reduce_142,
 1, 72, :_reduce_143,
 3, 92, :_reduce_144,
 2, 92, :_reduce_145,
 1, 96, :_reduce_none,
 1, 96, :_reduce_none,
 0, 78, :_reduce_none,
 1, 78, :_reduce_149 ]

racc_reduce_n = 150

racc_shift_n = 248

racc_action_table = [
    62,    50,    52,    50,    52,    92,    62,    50,    52,    58,
   157,    79,    62,    50,    52,    80,    73,  -110,    62,    50,
    52,   158,    73,   127,    62,    50,    52,    79,    73,   152,
    89,    45,    43,    45,   118,    65,    70,    45,    94,    74,
   118,    65,    70,    45,  -111,    74,   145,    65,    70,    45,
  -112,    74,   179,    65,   168,    45,    44,    74,   155,    65,
   114,    50,    52,    74,    62,    50,    52,    48,   193,   157,
    62,    50,    52,  -111,   142,   143,    62,    50,    52,  -113,
    73,   188,    62,    50,    52,  -109,    73,   127,    62,    50,
    52,    45,    73,   142,   143,    45,    94,   105,    73,    65,
    70,    45,    36,    74,    73,    65,    70,    45,  -109,    74,
   214,    65,    70,    45,   126,    74,   147,    65,    70,    45,
   223,    74,    35,    65,    70,   146,  -110,    74,    62,    50,
    52,   123,    32,   222,    62,    50,    52,  -110,    32,    31,
    62,    50,    52,   181,    73,    31,   182,    50,    52,   122,
    73,   218,   183,    50,    52,    48,    73,   186,   217,    45,
    39,   203,   118,    65,    70,    45,    39,    74,   118,    65,
    70,    45,   131,    74,   131,    65,    70,    45,    79,    74,
    48,    65,   168,    45,   208,    74,   106,    65,   168,    50,
    52,    74,   105,   183,    40,    50,    52,    41,   186,   211,
    40,    50,    52,    41,   118,   233,   127,   163,   164,   156,
   118,    50,    52,   155,   170,   128,   118,    50,    52,    45,
   150,   216,   219,    65,   168,    45,   118,    74,   131,    65,
   168,    45,   118,    74,   220,    65,   168,    93,   221,    74,
   149,    45,    50,    52,   224,    65,   168,    45,    45,    74,
    80,    65,   168,    94,    93,    74,    56,   118,    48,    50,
    52,    89,    56,  -114,   247,    45,    50,    52,    93,  -109,
    94,  -112,    45,  -111,    58,    17,    65,   168,    46,    45,
    74,    58,    50,    52,    94,    14,  -114,    20,    24,    45,
     1,     4,   209,     8,    54,    12,    45,    16,   155,    25,
   148,    54,   231,    17,   142,   143,    93,   161,    86,   246,
   131,   163,   164,    14,   235,    20,    24,    45,     1,     4,
    17,     8,    94,    12,   131,    16,   225,    25,    83,   132,
    14,   139,    20,    24,    81,     1,     4,    17,     8,   241,
    12,   138,    16,   227,    25,   137,   134,    14,    30,    20,
    24,  -112,     1,     4,    17,     8,   nil,    12,   nil,    16,
   228,    25,   nil,   nil,    14,   nil,    20,    24,   nil,     1,
     4,    17,     8,   nil,    12,   nil,    16,   240,    25,   nil,
   nil,    14,   nil,    20,    24,   nil,     1,     4,    17,     8,
   nil,    12,   nil,    16,   243,    25,   nil,   nil,    14,   nil,
    20,    24,   nil,     1,     4,    17,     8,   nil,    12,   nil,
    16,   189,    25,   nil,   nil,    14,   nil,    20,    24,   nil,
     1,     4,    17,     8,   nil,    12,   nil,    16,   191,    25,
   nil,   nil,    14,   nil,    20,    24,   nil,     1,     4,    17,
     8,   nil,    12,   nil,    16,   nil,    25,   nil,   nil,    14,
   nil,    20,    24,   nil,     1,     4,    17,     8,   nil,    12,
   nil,    16,   nil,    25,   nil,   nil,    14,   nil,    20,    24,
   nil,     1,     4,    17,     8,   nil,    12,   nil,    16,   nil,
    25,   nil,   nil,    14,   nil,    20,    24,   nil,     1,     4,
    17,     8,   nil,    12,   nil,    16,   nil,    25,   nil,   nil,
    14,   nil,    20,    24,   nil,     1,     4,    17,     8,   nil,
    12,   nil,    16,   nil,    25,   nil,   nil,    14,   nil,    20,
    24,   nil,     1,     4,   nil,     8,   nil,    12,   nil,    16,
   nil,    25 ]

racc_action_check = [
    48,    48,    48,   105,   105,    37,    79,    79,    79,   106,
   114,    17,   162,   162,   162,    17,    48,   195,   158,   158,
   158,   120,    79,   114,    56,    56,    56,    73,   162,   106,
    37,    48,     9,   105,   158,    48,    48,    79,   105,    48,
    56,    79,    79,   162,    72,    79,    96,   162,   162,   158,
    71,   162,   129,   158,   158,    56,     9,   158,   130,    56,
    56,   127,   127,    56,   157,   157,   157,    70,   141,   131,
    30,    30,    30,   117,    96,    96,    14,    14,    14,    77,
   157,   136,    16,    16,    16,   113,    30,    70,   211,   211,
   211,   127,    14,   141,   141,   157,   127,   174,    16,   157,
   157,    30,     6,   157,   211,    30,    30,    14,    69,    30,
   174,    14,    14,    16,    67,    14,   100,    16,    16,   211,
   185,    16,     6,   211,   211,   100,   110,   211,    62,    62,
    62,    62,     4,   185,   224,   224,   224,    63,    24,     4,
   220,   220,   220,   133,    62,    24,   133,   146,   146,    61,
   224,   177,   134,   218,   218,   152,   220,   134,   177,    62,
     8,   154,   146,    62,    62,   224,    92,    62,   218,   224,
   224,   220,   155,   224,   156,   220,   220,   146,    58,   220,
    54,   146,   146,   218,   159,   146,    51,   218,   218,   234,
   234,   218,    49,   223,     8,   170,   170,     8,   223,   167,
    92,   147,   147,    92,   234,   213,   168,   213,   213,   109,
   170,   126,   126,   108,   126,    78,   147,   175,   175,   234,
   104,   175,   180,   234,   234,   170,   126,   234,   182,   170,
   170,   147,   175,   170,   183,   147,   147,    44,   184,   147,
   103,   126,   128,   128,   186,   126,   126,   175,    44,   126,
    36,   175,   175,    44,    93,   175,    35,   128,    12,    12,
    12,    33,    12,    76,   245,    93,    46,    46,   144,   197,
    93,   198,   128,   199,    12,   245,   128,   128,    12,   144,
   128,    46,    20,    20,   144,   245,   200,   245,   245,    12,
   245,   245,   160,   245,    12,   245,    46,   245,   205,   245,
   102,    46,   209,   160,   102,   102,    43,   125,    25,   244,
    80,   125,   125,   160,   217,   160,   160,    43,   160,   160,
   244,   160,    43,   160,    83,   160,   188,   160,    21,    81,
   244,    91,   244,   244,    19,   244,   244,   188,   244,   231,
   244,    89,   244,   190,   244,    88,    85,   188,     1,   188,
   188,   116,   188,   188,   190,   188,   nil,   188,   nil,   188,
   192,   188,   nil,   nil,   190,   nil,   190,   190,   nil,   190,
   190,   192,   190,   nil,   190,   nil,   190,   226,   190,   nil,
   nil,   192,   nil,   192,   192,   nil,   192,   192,   226,   192,
   nil,   192,   nil,   192,   235,   192,   nil,   nil,   226,   nil,
   226,   226,   nil,   226,   226,   235,   226,   nil,   226,   nil,
   226,   137,   226,   nil,   nil,   235,   nil,   235,   235,   nil,
   235,   235,   137,   235,   nil,   235,   nil,   235,   139,   235,
   nil,   nil,   137,   nil,   137,   137,   nil,   137,   137,   139,
   137,   nil,   137,   nil,   137,   nil,   137,   nil,   nil,   139,
   nil,   139,   139,   nil,   139,   139,   241,   139,   nil,   139,
   nil,   139,   nil,   139,   nil,   nil,   241,   nil,   241,   241,
   nil,   241,   241,    23,   241,   nil,   241,   nil,   241,   nil,
   241,   nil,   nil,    23,   nil,    23,    23,   nil,    23,    23,
   122,    23,   nil,    23,   nil,    23,   nil,    23,   nil,   nil,
   122,   nil,   122,   122,   nil,   122,   122,     0,   122,   nil,
   122,   nil,   122,   nil,   122,   nil,   nil,     0,   nil,     0,
     0,   nil,     0,     0,   nil,     0,   nil,     0,   nil,     0,
   nil,     0 ]

racc_action_pointer = [
   489,   335,   nil,   nil,    94,   nil,    84,   nil,   156,    13,
   nil,   nil,   256,   nil,    74,   nil,    80,     9,   nil,   334,
   279,   322,   nil,   455,   100,   266,   nil,   nil,   nil,   nil,
    68,   nil,   nil,   226,   nil,   250,   244,    -5,   nil,   nil,
   nil,   nil,   nil,   284,   215,   nil,   263,   nil,    -2,   182,
   nil,   176,   nil,   nil,   178,   nil,    22,   nil,   176,   nil,
   nil,   143,   126,   116,   nil,   nil,   nil,    93,   nil,    87,
    65,    29,    23,    25,   nil,   nil,   242,    58,   209,     4,
   272,   329,   nil,   286,   nil,   324,   nil,   nil,   339,   303,
   nil,   325,   162,   232,   nil,   nil,    26,   nil,   nil,   nil,
   101,   nil,   256,   217,   215,     0,    -9,   nil,   203,   192,
   105,   nil,   nil,    64,     1,   nil,   330,    52,   nil,   nil,
   -18,   nil,   472,   nil,   nil,   302,   208,    58,   239,    47,
    48,    60,   nil,   136,   119,   nil,    75,   404,   nil,   421,
   nil,    45,   nil,   nil,   246,   nil,   144,   198,   nil,   nil,
   nil,   nil,   153,   nil,   154,   134,   136,    62,    16,   177,
   285,   nil,    10,   nil,   nil,   nil,   nil,   190,   184,   nil,
   192,   nil,   nil,   nil,    87,   214,   nil,   141,   nil,   nil,
   215,   nil,   190,   221,   215,   110,   231,   nil,   319,   nil,
   336,   nil,   353,   nil,   nil,    -4,   nil,   248,   250,   252,
   265,   nil,   nil,   nil,   nil,   288,   nil,   nil,   nil,   273,
   nil,    86,   nil,   198,   nil,   nil,   nil,   308,   150,   nil,
   138,   nil,   nil,   160,   132,   nil,   370,   nil,   nil,   nil,
   nil,   333,   nil,   nil,   186,   387,   nil,   nil,   nil,   nil,
   nil,   438,   nil,   nil,   302,   257,   nil,   nil ]

racc_action_default = [
  -130,  -150,   -16,    -5,  -150,    -6,  -150,    -7,  -150,  -150,
    -8,    -9,   -37,   -10,  -150,   -11,  -150,   -36,   -12,  -150,
  -150,  -150,   -13,    -1,  -150,   -33,   -14,    -2,   -15,    -3,
  -150,  -124,  -123,  -130,   -32,  -150,  -150,  -130,  -125,  -128,
  -127,  -129,   -35,  -130,  -130,  -143,  -150,   -18,  -150,   -19,
   -87,   -20,   -88,   -21,   -56,   -23,   -65,   -24,  -150,   -25,
   -26,  -150,  -150,   -79,   -81,   -89,   -83,  -150,   -95,   -78,
   -56,   -82,   -77,   -57,  -115,   -84,   -80,   -85,  -150,  -150,
   -65,  -150,  -116,   -65,    -4,  -130,   -34,   -64,  -150,  -150,
  -141,  -150,  -150,  -130,   -56,   -50,  -150,   -49,   -41,   -43,
  -150,   -40,  -150,  -150,  -150,  -150,  -150,   -52,  -148,  -150,
   -60,   -61,   -63,   -59,   -56,   -66,   -62,   -58,   -57,  -114,
   -54,  -113,  -150,  -145,   -69,  -150,  -150,  -150,  -150,  -150,
  -148,  -150,   248,  -150,  -131,  -132,  -150,  -150,  -142,  -150,
  -126,  -150,   -46,   -45,  -150,   -39,  -150,  -150,   -38,   -17,
   -90,   -22,  -150,   -27,  -150,  -149,   -65,  -150,   -55,  -150,
  -150,  -144,  -150,  -146,  -147,  -110,  -109,  -150,   -56,  -112,
  -150,  -103,  -111,  -104,  -150,  -150,   -97,  -150,  -101,   -91,
  -150,   -31,  -150,  -140,  -150,  -150,  -138,  -135,  -150,  -120,
  -150,  -122,  -150,   -44,   -42,   -73,   -75,   -72,   -76,   -71,
   -74,   -47,   -48,   -29,   -67,  -148,   -68,   -53,   -28,   -93,
   -70,  -150,  -106,  -150,   -86,   -98,   -96,  -150,  -150,   -30,
  -150,  -133,  -134,  -150,  -150,  -118,  -150,  -119,  -121,   -51,
   -92,  -150,  -108,  -105,  -150,  -150,  -102,  -139,  -136,  -137,
  -117,  -150,  -107,  -100,  -150,  -150,   -99,   -94 ]

racc_goto_table = [
    23,    59,   173,    84,   107,   108,    38,   187,    33,    82,
    57,   112,   167,   204,   178,   154,    55,   111,    96,   102,
   176,    88,   175,   162,    47,    91,   201,   202,    85,   130,
   125,    61,   133,   230,   174,    59,   151,   180,    27,    34,
   204,    97,    97,   171,    57,   117,   212,    95,    95,   120,
    55,   213,   159,    68,   116,    78,   167,   136,   103,    42,
   113,   178,    37,   194,   184,   185,    19,   215,   141,    87,
   nil,    90,   nil,   nil,   nil,    90,   nil,   nil,   nil,   nil,
   nil,   nil,   nil,   nil,   nil,   nil,   nil,   104,   nil,   nil,
   140,    97,   nil,   nil,    59,   119,   238,    95,   nil,   nil,
   nil,   124,   nil,    57,   236,   205,   207,   196,   196,    55,
   242,   234,   229,   112,   nil,   172,    59,   172,   129,   111,
   167,   nil,   160,   135,   169,    57,   169,   nil,   nil,   nil,
   166,    55,   166,   nil,   nil,   199,   199,   190,   nil,   192,
    84,   nil,    97,   nil,   198,   198,   nil,   117,    95,   nil,
   197,   197,   nil,    60,   nil,    75,   116,    75,   121,   172,
   nil,   nil,   113,   nil,   172,   119,   nil,   119,   169,   nil,
    84,    75,    84,   169,   166,   nil,   nil,   nil,   nil,   166,
   nil,   nil,   nil,   nil,   nil,   200,   200,    60,   226,    75,
   nil,   nil,   110,   nil,   nil,   nil,   206,   119,   nil,   nil,
   nil,   210,   nil,    75,   nil,   nil,    84,   172,   nil,   119,
   nil,   nil,   nil,   nil,   119,   nil,   169,   nil,   nil,   nil,
    75,   nil,   166,   172,    84,    84,   nil,   nil,   121,   nil,
   121,   nil,   169,   nil,   nil,   244,   nil,   nil,   166,   nil,
   nil,   245,   nil,   nil,   nil,   nil,   nil,   153,   121,   121,
   232,   nil,   nil,   nil,   nil,   nil,   nil,   119,   nil,   237,
   121,   nil,   165,   239,   165,   nil,   nil,   nil,   nil,   nil,
   nil,   nil,   121,   119,   nil,   nil,   nil,   121,   nil,   nil,
   nil,   nil,   195,   195,   nil,   nil,   nil,   nil,   nil,   nil,
   nil,   nil,   nil,   nil,   110,   nil,   nil,   nil,    75,   nil,
   nil,   nil,   nil,    75,   nil,   nil,   165,   nil,   nil,   nil,
   nil,   165,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
   121,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
   nil,   nil,   nil,   nil,   nil,   nil,   121,   nil,   nil,   nil,
   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
   nil,   nil,    75,   nil,   165,   nil,   nil,   nil,   nil,   nil,
   nil,    75,   nil,   nil,   nil,    75,   nil,   nil,   nil,   nil,
   165 ]

racc_goto_check = [
     2,    23,    56,     4,    38,    27,    62,    65,    58,    23,
    22,    42,    54,    44,    54,    28,    21,    41,    32,    32,
    52,    60,    51,    46,    17,    60,    37,    37,    58,    27,
    45,    49,    27,    50,    18,    23,    20,    28,     3,     5,
    44,    22,    22,    55,    22,    23,    56,    21,    21,    25,
    21,    57,    26,    43,    22,    43,    54,    59,    17,    31,
    21,    54,    61,    33,    63,    64,     1,    52,    32,    43,
   nil,     3,   nil,   nil,   nil,     3,   nil,   nil,   nil,   nil,
   nil,   nil,   nil,   nil,   nil,   nil,   nil,    43,   nil,   nil,
    62,    22,   nil,   nil,    23,    47,    65,    21,   nil,   nil,
   nil,    43,   nil,    22,    54,    27,    38,    41,    41,    21,
    56,    46,    28,    42,   nil,    23,    23,    23,    43,    41,
    54,   nil,     2,     3,    22,    22,    22,   nil,   nil,   nil,
    21,    21,    21,   nil,   nil,    23,    23,     2,   nil,     2,
     4,   nil,    22,   nil,    22,    22,   nil,    23,    21,   nil,
    21,    21,   nil,    24,   nil,    24,    22,    24,    48,    23,
   nil,   nil,    21,   nil,    23,    47,   nil,    47,    22,   nil,
     4,    24,     4,    22,    21,   nil,   nil,   nil,   nil,    21,
   nil,   nil,   nil,   nil,   nil,    47,    47,    24,     2,    24,
   nil,   nil,    40,   nil,   nil,   nil,    43,    47,   nil,   nil,
   nil,    43,   nil,    24,   nil,   nil,     4,    23,   nil,    47,
   nil,   nil,   nil,   nil,    47,   nil,    22,   nil,   nil,   nil,
    24,   nil,    21,    23,     4,     4,   nil,   nil,    48,   nil,
    48,   nil,    22,   nil,   nil,     2,   nil,   nil,    21,   nil,
   nil,     2,   nil,   nil,   nil,   nil,   nil,    24,    48,    48,
    43,   nil,   nil,   nil,   nil,   nil,   nil,    47,   nil,    43,
    48,   nil,    40,    43,    40,   nil,   nil,   nil,   nil,   nil,
   nil,   nil,    48,    47,   nil,   nil,   nil,    48,   nil,   nil,
   nil,   nil,    40,    40,   nil,   nil,   nil,   nil,   nil,   nil,
   nil,   nil,   nil,   nil,    40,   nil,   nil,   nil,    24,   nil,
   nil,   nil,   nil,    24,   nil,   nil,    40,   nil,   nil,   nil,
   nil,    40,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    48,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
   nil,   nil,   nil,   nil,   nil,   nil,    48,   nil,   nil,   nil,
   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
   nil,   nil,    24,   nil,    40,   nil,   nil,   nil,   nil,   nil,
   nil,    24,   nil,   nil,   nil,    24,   nil,   nil,   nil,   nil,
    40 ]

racc_goto_pointer = [
   nil,    66,     0,    38,   -20,    33,   nil,   nil,   nil,   nil,
   nil,   nil,   nil,   nil,   nil,   nil,   nil,    12,   -93,   nil,
   -69,     4,    -2,   -11,   141,    -7,   -68,   -51,   -93,   nil,
   nil,    50,   -25,   -81,   nil,   nil,   nil,  -120,   -52,   nil,
   136,   -39,   -45,    39,  -142,   -32,  -102,    39,   102,    17,
  -176,  -106,  -108,   nil,  -114,   -83,  -124,  -119,     4,   -28,
   -12,    54,    -2,   -70,   -69,  -127 ]

racc_goto_default = [
   nil,   nil,   nil,   101,    29,     3,     5,     7,    10,    11,
    13,    15,    18,    22,    26,    28,     2,   nil,    49,    51,
    53,    69,    71,    72,    21,   nil,   nil,   nil,   nil,     6,
     9,   nil,   nil,    98,   144,    99,   100,   nil,   nil,   109,
    63,    64,    66,   nil,   115,   nil,   nil,    76,    77,   nil,
   nil,   nil,   nil,   177,    67,   nil,   nil,   nil,   nil,   nil,
   nil,   nil,   nil,   nil,   nil,   nil ]

racc_token_table = {
 false => 0,
 Object.new => 1,
 :LBRACK => 2,
 :DQTEXT => 3,
 :SQTEXT => 4,
 :RBRACK => 5,
 :LBRACE => 6,
 :RBRACE => 7,
 :SYMBOL => 8,
 :FARROW => 9,
 :COMMA => 10,
 :TRUE => 11,
 :FALSE => 12,
 :EQUALS => 13,
 :LESSEQUAL => 14,
 :NOTEQUAL => 15,
 :DOT => 16,
 :COLON => 17,
 :TYPE => 18,
 :LLCOLLECT => 19,
 :RRCOLLECT => 20,
 :QMARK => 21,
 :LPAREN => 22,
 :RPAREN => 23,
 :ISEQUAL => 24,
 :GREATEREQUAL => 25,
 :GREATERTHAN => 26,
 :LESSTHAN => 27,
 :IF => 28,
 :ELSE => 29,
 :IMPORT => 30,
 :DEFINE => 31,
 :ELSIF => 32,
 :VARIABLE => 33,
 :CLASS => 34,
 :INHERITS => 35,
 :NODE => 36,
 :BOOLEAN => 37,
 :NAME => 38,
 :SEMIC => 39,
 :CASE => 40,
 :DEFAULT => 41,
 :AT => 42,
 :LCOLLECT => 43,
 :RCOLLECT => 44,
 :CLASSNAME => 45,
 :CLASSREF => 46,
 :NOT => 47,
 :OR => 48,
 :AND => 49 }

racc_use_result_var = true

racc_nt_base = 50

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',
'DQTEXT',
'SQTEXT',
'RBRACK',
'LBRACE',
'RBRACE',
'SYMBOL',
'FARROW',
'COMMA',
'TRUE',
'FALSE',
'EQUALS',
'LESSEQUAL',
'NOTEQUAL',
'DOT',
'COLON',
'TYPE',
'LLCOLLECT',
'RRCOLLECT',
'QMARK',
'LPAREN',
'RPAREN',
'ISEQUAL',
'GREATEREQUAL',
'GREATERTHAN',
'LESSTHAN',
'IF',
'ELSE',
'IMPORT',
'DEFINE',
'ELSIF',
'VARIABLE',
'CLASS',
'INHERITS',
'NODE',
'BOOLEAN',
'NAME',
'SEMIC',
'CASE',
'DEFAULT',
'AT',
'LCOLLECT',
'RCOLLECT',
'CLASSNAME',
'CLASSREF',
'NOT',
'OR',
'AND',
'$start',
'program',
'statements',
'nil',
'statement',
'resource',
'virtualresource',
'collection',
'assignment',
'casestatement',
'ifstatement',
'import',
'fstatement',
'definition',
'hostclass',
'nodedef',
'resourceoverride',
'funcvalues',
'namestrings',
'resourcerefs',
'namestring',
'name',
'variable',
'quotedtext',
'resourceref',
'resourceinstances',
'endsemi',
'params',
'endcomma',
'at',
'collectname',
'collectrhand',
'collstatements',
'collstatement',
'colljoin',
'collexpr',
'colllval',
'simplervalue',
'resourceinst',
'resourcename',
'type',
'selector',
'array',
'rvalue',
'param',
'rvalues',
'comma',
'boolean',
'funcrvalue',
'iftest',
'else',
'caseopts',
'caseopt',
'casevalues',
'selectlhand',
'svalues',
'selectval',
'sintvalues',
'fqname',
'argumentlist',
'parent',
'hostnames',
'hostname',
'nothing',
'arguments',
'argument']

Racc_debug_parser = false

##### racc system variables end #####

 # reduce 0 omitted

module_eval <<'.,.,', 'grammar.ra', 33
  def _reduce_1( val, _values, result )
    if val[0]
        # Make sure we always return an array.
        if val[0].is_a?(AST::ASTArray)
            if val[0].children.empty?
                result = nil
            else
                result = val[0]
            end
        else
            result = aryfy(val[0])
        end
    else
        result = nil
    end
   result
  end
.,.,

 # reduce 2 omitted

 # reduce 3 omitted

module_eval <<'.,.,', 'grammar.ra', 49
  def _reduce_4( val, _values, result )
    if val[0] and val[1]
        if val[0].instance_of?(AST::ASTArray)
            val[0].push(val[1])
            result = val[0]
        else
            result = ast AST::ASTArray, :children => [val[0],val[1]]
        end
    elsif obj = (val[0] || val[1])
        result = obj
    else result = nil
    end
   result
  end
.,.,

 # reduce 5 omitted

 # reduce 6 omitted

 # reduce 7 omitted

 # reduce 8 omitted

 # reduce 9 omitted

 # reduce 10 omitted

 # reduce 11 omitted

 # reduce 12 omitted

 # reduce 13 omitted

 # reduce 14 omitted

 # reduce 15 omitted

 # reduce 16 omitted

module_eval <<'.,.,', 'grammar.ra', 71
  def _reduce_17( val, _values, result )
    args = aryfy(val[2])
    result = ast AST::Function,
        :name => val[0],
        :arguments => args,
        :ftype => :statement
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 78
  def _reduce_18( val, _values, result )
    args = aryfy(val[1])
    result = ast AST::Function,
        :name => val[0],
        :arguments => args,
        :ftype => :statement
   result
  end
.,.,

 # reduce 19 omitted

 # reduce 20 omitted

 # reduce 21 omitted

module_eval <<'.,.,', 'grammar.ra', 88
  def _reduce_22( val, _values, result )
    result = aryfy(val[0], val[2])
    result.line = @lexer.line
    result.file = @lexer.file
   result
  end
.,.,

 # reduce 23 omitted

 # reduce 24 omitted

 # reduce 25 omitted

 # reduce 26 omitted

module_eval <<'.,.,', 'grammar.ra', 103
  def _reduce_27( val, _values, result )
    unless val[0].is_a?(AST::ASTArray)
        val[0] = aryfy(val[0])
    end

    val[0].push(val[2])

    result = val[0]
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 127
  def _reduce_28( val, _values, result )
    if val[0].instance_of?(AST::ASTArray)
        error "Invalid name"
    end
    array = val[2]
    if array.instance_of?(AST::ResourceInst)
        array = [array]
    end
    result = ast AST::ASTArray

    # this iterates across each specified resourceinstance
    array.each { |instance|
        unless instance.instance_of?(AST::ResourceInst)
            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(AST::ResourceDef,
            :type => val[0],
            :title => instance[0],
            :params => instance[1])
    }
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 130
  def _reduce_29( val, _values, result )
    # This is a deprecated syntax.
    error "All resource specifications require names"
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 136
  def _reduce_30( val, _values, result )
    # a template setting for a type
    if val[0].instance_of?(AST::ASTArray)
        error "Invalid type"
    end
    result = ast(AST::ResourceDefaults, :type => val[0], :params => val[2])
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 141
  def _reduce_31( val, _values, result )
    result = ast AST::ResourceOverride, :object => val[0], :params => val[2]
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 168
  def _reduce_32( val, _values, result )
    type = val[0]

    if type == :exported and ! Puppet[:storeconfigs]
        error "You cannot collect without storeconfigs being set"
    end

    if val[1].is_a? AST::ResourceDefaults
        error "Defaults are not virtualizable"
    end

    method = type.to_s + "="

    # Just mark our resources as exported and pass them through.
    if val[1].instance_of?(AST::ASTArray)
        val[1].each do |obj|
            obj.send(method, true)
        end
    else
        val[1].send(method, true)
    end

    result = val[1]
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 169
  def _reduce_33( val, _values, result )
 result = :virtual
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 170
  def _reduce_34( val, _values, result )
 result = :exported
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 193
  def _reduce_35( val, _values, result )
    if val[0] =~ /^[a-z]/
        Puppet.warning addcontext("Collection names must now be capitalized")
    end
    type = val[0].downcase
    args = {:type => type}

    if val[1].is_a?(AST::CollExpr)
        args[:query] = val[1]
        args[:query].type = type
        args[:form] = args[:query].form
    else
        args[:form] = val[1]
    end
    if args[:form] == :exported and ! Puppet[:storeconfigs]
        error "You cannot collect exported resources without storeconfigs being set"
    end
    result = ast AST::Collection, args
   result
  end
.,.,

 # reduce 36 omitted

 # reduce 37 omitted

module_eval <<'.,.,', 'grammar.ra', 204
  def _reduce_38( val, _values, result )
    if val[1]
        result = val[1]
        result.form = :virtual
    else
        result = :virtual
    end
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 212
  def _reduce_39( val, _values, result )
    if val[1]
        result = val[1]
        result.form = :exported
    else
        result = :exported
    end
   result
  end
.,.,

 # reduce 40 omitted

 # reduce 41 omitted

module_eval <<'.,.,', 'grammar.ra', 220
  def _reduce_42( val, _values, result )
    result = ast AST::CollExpr, :test1 => val[0], :oper => val[1], :test2 => val[2]
   result
  end
.,.,

 # reduce 43 omitted

module_eval <<'.,.,', 'grammar.ra', 226
  def _reduce_44( val, _values, result )
    result = val[1]
    result.parens = true
   result
  end
.,.,

 # reduce 45 omitted

 # reduce 46 omitted

module_eval <<'.,.,', 'grammar.ra', 234
  def _reduce_47( val, _values, result )
    result = ast AST::CollExpr, :test1 => val[0], :oper => val[1], :test2 => val[2]
    #result = ast AST::CollExpr
    #result.push *val
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 239
  def _reduce_48( val, _values, result )
    result = ast AST::CollExpr, :test1 => val[0], :oper => val[1], :test2 => val[2]
    #result = ast AST::CollExpr
    #result.push *val
   result
  end
.,.,

 # reduce 49 omitted

 # reduce 50 omitted

module_eval <<'.,.,', 'grammar.ra', 246
  def _reduce_51( val, _values, result )
    result = ast AST::ResourceInst, :children => [val[0],val[2]]
   result
  end
.,.,

 # reduce 52 omitted

module_eval <<'.,.,', 'grammar.ra', 256
  def _reduce_53( val, _values, result )
    if val[0].instance_of?(AST::ResourceInst)
        result = ast AST::ASTArray, :children => [val[0],val[2]]
    else
        val[0].push val[2]
        result = val[0]
    end
   result
  end
.,.,

 # reduce 54 omitted

 # reduce 55 omitted

module_eval <<'.,.,', 'grammar.ra', 263
  def _reduce_56( val, _values, result )
    result = ast AST::Name, :value => val[0]
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 267
  def _reduce_57( val, _values, result )
    result = ast AST::Type, :value => val[0]
   result
  end
.,.,

 # reduce 58 omitted

 # reduce 59 omitted

 # reduce 60 omitted

 # reduce 61 omitted

 # reduce 62 omitted

 # reduce 63 omitted

module_eval <<'.,.,', 'grammar.ra', 280
  def _reduce_64( val, _values, result )
    # this is distinct from referencing a variable
    variable = ast AST::Name, :value => val[0]
    result = ast AST::VarDef, :name => variable, :value => val[2]
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 285
  def _reduce_65( val, _values, result )
    result = ast AST::ASTArray
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 285
  def _reduce_66( val, _values, result )
 result = val[0]
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 294
  def _reduce_67( val, _values, result )
    if val[0].instance_of?(AST::ASTArray)
        val[0].push(val[2])
        result = val[0]
    else
        result = ast AST::ASTArray, :children => [val[0],val[2]]
    end
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 298
  def _reduce_68( val, _values, result )
    result = ast AST::ResourceParam, :param => val[0], :value => val[2]
   result
  end
.,.,

 # reduce 69 omitted

module_eval <<'.,.,', 'grammar.ra', 307
  def _reduce_70( val, _values, result )
    if val[0].instance_of?(AST::ASTArray)
        result = val[0].push(val[2])
    else
        result = ast AST::ASTArray, :children => [val[0],val[2]]
    end
   result
  end
.,.,

 # reduce 71 omitted

 # reduce 72 omitted

 # reduce 73 omitted

 # reduce 74 omitted

 # reduce 75 omitted

 # reduce 76 omitted

 # reduce 77 omitted

 # reduce 78 omitted

 # reduce 79 omitted

 # reduce 80 omitted

 # reduce 81 omitted

 # reduce 82 omitted

 # reduce 83 omitted

 # reduce 84 omitted

 # reduce 85 omitted

module_eval <<'.,.,', 'grammar.ra', 333
  def _reduce_86( val, _values, result )
    args = aryfy(val[2])
    result = ast AST::Function,
        :name => val[0],
        :arguments => args,
        :ftype => :rvalue
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 337
  def _reduce_87( val, _values, result )
    result = ast AST::String, :value => val[0]
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 339
  def _reduce_88( val, _values, result )
    result = ast AST::FlatString, :value => val[0]
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 343
  def _reduce_89( val, _values, result )
    result = ast AST::Boolean, :value => val[0]
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 348
  def _reduce_90( val, _values, result )
    Puppet.warning addcontext("Deprecation notice:  Resource references should now be capitalized")
    result = ast AST::ResourceRef, :type => val[0], :title => val[2]
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 350
  def _reduce_91( val, _values, result )
    result = ast AST::ResourceRef, :type => val[0], :title => val[2]
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 363
  def _reduce_92( val, _values, result )
    args = {
        :test => val[1],
        :statements => val[3]
    }

    if val[5]
        args[:else] = val[5]
    end

    result = ast AST::IfStatement, args
   result
  end
.,.,

 # reduce 93 omitted

module_eval <<'.,.,', 'grammar.ra', 368
  def _reduce_94( val, _values, result )
    result = ast AST::Else, :statements => val[2]
   result
  end
.,.,

 # reduce 95 omitted

module_eval <<'.,.,', 'grammar.ra', 380
  def _reduce_96( val, _values, result )
    options = val[3]
    unless options.instance_of?(AST::ASTArray)
        options = ast AST::ASTArray, :children => [val[3]]
    end
    result = ast AST::CaseStatement, :test => val[1], :options => options
   result
  end
.,.,

 # reduce 97 omitted

module_eval <<'.,.,', 'grammar.ra', 390
  def _reduce_98( val, _values, result )
    if val[0].instance_of?(AST::ASTArray)
        val[0].push val[1]
        result = val[0]
    else
        result = ast AST::ASTArray, :children => [val[0], val[1]]
    end
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 394
  def _reduce_99( val, _values, result )
    result = ast AST::CaseOpt, :value => val[0], :statements => val[3]
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 399
  def _reduce_100( val, _values, result )
    result = ast(AST::CaseOpt,
        :value => val[0],
        :statements => ast(AST::ASTArray)
    )
   result
  end
.,.,

 # reduce 101 omitted

module_eval <<'.,.,', 'grammar.ra', 409
  def _reduce_102( val, _values, result )
    if val[0].instance_of?(AST::ASTArray)
        val[0].push(val[2])
        result = val[0]
    else
        result = ast AST::ASTArray, :children => [val[0],val[2]]
    end
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 413
  def _reduce_103( val, _values, result )
    result = ast AST::Selector, :param => val[0], :values => val[2]
   result
  end
.,.,

 # reduce 104 omitted

module_eval <<'.,.,', 'grammar.ra', 415
  def _reduce_105( val, _values, result )
 result = val[1]
   result
  end
.,.,

 # reduce 106 omitted

module_eval <<'.,.,', 'grammar.ra', 426
  def _reduce_107( val, _values, result )
    if val[0].instance_of?(AST::ASTArray)
        val[0].push(val[2])
        result = val[0]
    else
        result = ast AST::ASTArray, :children => [val[0],val[2]]
    end
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 430
  def _reduce_108( val, _values, result )
    result = ast AST::ResourceParam, :param => val[0], :value => val[2]
   result
  end
.,.,

 # reduce 109 omitted

 # reduce 110 omitted

 # reduce 111 omitted

 # reduce 112 omitted

 # reduce 113 omitted

 # reduce 114 omitted

module_eval <<'.,.,', 'grammar.ra', 440
  def _reduce_115( val, _values, result )
    result = ast AST::Default, :value => val[0]
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 502
  def _reduce_116( 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 AST::ASTArray

    Dir.chdir(dir) {
        # We can't interpolate at this point since we don't have any 
        # scopes set up. Warn the user if they use a variable reference
        pat = val[1].value
        if pat.index("$")
             Puppet.warning(
                 "The import of #{pat} contains a variable reference;" +
                 " variables are not interpolated for imports " +
                 "in file #{@lexer.file} at line #{@lexer.line}"
             )
        end
        files = Dir.glob(pat)
        if files.size == 0
            files = Dir.glob(pat + ".pp")
            if files.size == 0
                raise Puppet::ImportError.new("No file(s) found for import " + 
                                              "of '#{pat}'")
            end
        end

        files.each { |file|
            parser = Puppet::Parser::Parser.new(interp)
            parser.files = self.files
            Puppet.debug("importing '%s'" % file)

            unless file =~ /^#{File::SEPARATOR}/
                file = File.join(dir, file)
            end
            begin
                parser.file = file
            rescue Puppet::ImportError
                Puppet.warning(
                    "Importing %s would result in an import loop" %
                        File.join(dir, file)
                )
                next
            end
            # push the results into the main result array
            # We always return an array when we parse.
            ast = parser.parse

            # Things that just get added to the classtable or whatever return nil
            if ast
                ast.each do |child|
                    result.push child
                end
            end
        }
    }
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 512
  def _reduce_117( val, _values, result )
    interp.newdefine fqname(val[1]), :arguments => val[2], :code => val[4]
    @lexer.indefine = false
    result = nil

#}           | DEFINE NAME argumentlist parent LBRACE RBRACE {
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 516
  def _reduce_118( val, _values, result )
    interp.newdefine fqname(val[1]), :arguments => val[2]
    @lexer.indefine = false
    result = nil
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 524
  def _reduce_119( val, _values, result )
    # Our class gets defined in the parent namespace, not our own.
    @lexer.namepop
    interp.newclass fqname(val[1]), :code => val[4], :parent => val[2]
    result = nil
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 529
  def _reduce_120( val, _values, result )
    # Our class gets defined in the parent namespace, not our own.
    @lexer.namepop
    interp.newclass fqname(val[1]), :parent => val[2]
    result = nil
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 534
  def _reduce_121( val, _values, result )
    interp.newnode val[1], :parent => val[2], :code => val[4]
    result = nil
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 537
  def _reduce_122( val, _values, result )
    interp.newnode val[1], :parent => val[2]
    result = nil
   result
  end
.,.,

 # reduce 123 omitted

 # reduce 124 omitted

 # reduce 125 omitted

module_eval <<'.,.,', 'grammar.ra', 549
  def _reduce_126( val, _values, result )
    result = val[0]
    result = [result] unless result.is_a?(Array)
    result << val[2]
   result
  end
.,.,

 # reduce 127 omitted

 # reduce 128 omitted

 # reduce 129 omitted

module_eval <<'.,.,', 'grammar.ra', 557
  def _reduce_130( val, _values, result )
    result = nil
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 561
  def _reduce_131( val, _values, result )
    result = ast AST::ASTArray, :children => []
   result
  end
.,.,

 # reduce 132 omitted

module_eval <<'.,.,', 'grammar.ra', 566
  def _reduce_133( val, _values, result )
    result = nil
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 570
  def _reduce_134( val, _values, result )
    result = val[1]
    result = [result] unless result[0].is_a?(Array)
   result
  end
.,.,

 # reduce 135 omitted

module_eval <<'.,.,', 'grammar.ra', 577
  def _reduce_136( val, _values, result )
    result = val[0]
    result = [result] unless result[0].is_a?(Array)
    result << val[2]
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 582
  def _reduce_137( val, _values, result )
    Puppet.warning addcontext("Deprecation notice:  #{val[0].value} must now include '$' in prototype")
    result = [val[0], val[2]]
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 586
  def _reduce_138( val, _values, result )
    Puppet.warning addcontext("Deprecation notice:  #{val[0].value} must now include '$' in prototype")
    result = [val[0]]
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 588
  def _reduce_139( val, _values, result )
    result = [val[0], val[2]]
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 590
  def _reduce_140( val, _values, result )
    result = [val[0]]
   result
  end
.,.,

 # reduce 141 omitted

module_eval <<'.,.,', 'grammar.ra', 595
  def _reduce_142( val, _values, result )
    result = val[1]
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 599
  def _reduce_143( val, _values, result )
    result = ast AST::Variable, :value => val[0]
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 607
  def _reduce_144( val, _values, result )
    if val[1].instance_of?(AST::ASTArray)
        result = val[1]
    else
        result = ast AST::ASTArray, :children => [val[1]]
    end
   result
  end
.,.,

module_eval <<'.,.,', 'grammar.ra', 609
  def _reduce_145( val, _values, result )
    result = ast AST::ASTArray
   result
  end
.,.,

 # reduce 146 omitted

 # reduce 147 omitted

 # reduce 148 omitted

module_eval <<'.,.,', 'grammar.ra', 614
  def _reduce_149( val, _values, result )
 result = nil
   result
  end
.,.,

 def _reduce_none( val, _values, result )
  result
 end

    end   # class Parser

  end   # module Parser

end   # module Puppet