puppet 3.5.0.rc1-x86-mingw32

data/lib/puppet/parser/functions/require.rb

@@ -0,0 +1,53 @@
+# Requires the specified classes
+
+  Puppet::Parser::Functions::newfunction(
+    :require,
+    :arity => -2,
+    :doc =>"Evaluate one or more classes,  adding the required class as a dependency.
+
+The relationship metaparameters work well for specifying relationships
+between individual resources, but they can be clumsy for specifying
+relationships between classes.  This function is a superset of the
+'include' function, adding a class relationship so that the requiring
+class depends on the required class.
+
+Warning: using require in place of include can lead to unwanted dependency cycles.
+
+For instance the following manifest, with 'require' instead of 'include' would produce a nasty dependence cycle, because notify imposes a before between File[/foo] and Service[foo]:
+
+    class myservice {
+      service { foo: ensure => running }
+    }
+
+    class otherstuff {
+      include myservice
+      file { '/foo': notify => Service[foo] }
+    }
+
+Note that this function only works with clients 0.25 and later, and it will
+fail if used with earlier clients.
+
+") do |vals|
+  # Verify that the 'include' function is loaded
+  method = Puppet::Parser::Functions.function(:include)
+
+  send(method, vals)
+  vals = [vals] unless vals.is_a?(Array)
+
+  vals.each do |klass|
+    # lookup the class in the scopes
+    if classobj = find_hostclass(klass)
+      klass = classobj.name
+    else
+      raise Puppet::ParseError, "Could not find class #{klass}"
+    end
+
+    # This is a bit hackish, in some ways, but it's the only way
+    # to configure a dependency that will make it to the client.
+    # The 'obvious' way is just to add an edge in the catalog,
+    # but that is considered a containment edge, not a dependency
+    # edge, so it usually gets lost on the client.
+    ref = Puppet::Resource.new(:class, klass)
+    resource.set_parameter(:require, [resource[:require]].flatten.compact << ref)
+  end
+end

data/lib/puppet/parser/functions/search.rb

@@ -0,0 +1,7 @@
+Puppet::Parser::Functions::newfunction(:search, :arity => -2, :doc => "Add another namespace for this class to search.
+    This allows you to create classes with sets of definitions and add
+    those classes to another class's search path.") do |vals|
+    vals.each do |val|
+      add_namespace(val)
+    end
+end

data/lib/puppet/parser/functions/select.rb

@@ -0,0 +1,15 @@
+Puppet::Parser::Functions::newfunction(
+:select,
+:type => :rvalue,
+:arity => 2,
+:doc => <<-'ENDHEREDOC') do |args|
+  The 'select' function has been renamed to 'filter'. Please update your manifests.
+
+  The select function is reserved for future use.
+  - Removed as of 3.4
+  - requires `parser = future`.
+  ENDHEREDOC
+
+  raise NotImplementedError,
+    "The 'select' function has been renamed to 'filter'. Please update your manifests."
+end

data/lib/puppet/parser/functions/sha1.rb

@@ -0,0 +1,5 @@
+require 'digest/sha1'
+
+Puppet::Parser::Functions::newfunction(:sha1, :type => :rvalue, :arity => 1, :doc => "Returns a SHA1 hash value from a provided string.") do |args|
+      Digest::SHA1.hexdigest(args[0])
+end

data/lib/puppet/parser/functions/shellquote.rb

@@ -0,0 +1,61 @@
+# Copyright (C) 2009 Thomas Bellman
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THOMAS BELLMAN BE LIABLE FOR ANY CLAIM, DAMAGES OR
+# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.
+#
+# Except as contained in this notice, the name of Thomas Bellman shall
+# not be used in advertising or otherwise to promote the sale, use or
+# other dealings in this Software without prior written authorization
+# from Thomas Bellman.
+
+Puppet::Parser::Functions.newfunction(:shellquote, :type => :rvalue, :arity => -1, :doc => "\
+    Quote and concatenate arguments for use in Bourne shell.
+
+    Each argument is quoted separately, and then all are concatenated
+    with spaces.  If an argument is an array, the elements of that
+    array is interpolated within the rest of the arguments; this makes
+    it possible to have an array of arguments and pass that array to
+    shellquote instead of having to specify each argument
+    individually in the call.
+    ") \
+do |args|
+  safe = 'a-zA-Z0-9@%_+=:,./-'    # Safe unquoted
+  dangerous = '!"`$\\'            # Unsafe inside double quotes
+
+  result = []
+  args.flatten.each do |word|
+    if word.length != 0 and word.count(safe) == word.length
+      result << word
+    elsif word.count(dangerous) == 0
+      result << ('"' + word + '"')
+    elsif word.count("'") == 0
+      result << ("'" + word + "'")
+    else
+      r = '"'
+      word.each_byte do |c|
+        r += "\\" if dangerous.include?(c.chr)
+        r += c.chr
+      end
+      r += '"'
+      result << r
+    end
+  end
+
+  return result.join(" ")
+end

data/lib/puppet/parser/functions/slice.rb

@@ -0,0 +1,116 @@
+Puppet::Parser::Functions::newfunction(
+:slice,
+:type => :rvalue,
+:arity => -2,
+:doc => <<-'ENDHEREDOC') do |args|
+  Applies a parameterized block to each _slice_ of elements in a sequence of selected entries from the first
+  argument and returns the first argument, or if no block is given returns a new array with a concatenation of
+  the slices.
+
+  This function takes two mandatory arguments: the first, `$a`, should be an Array, Hash, or something of
+  enumerable type (integer, Integer range, or String), and the second, `$n`, the number of elements to include
+  in each slice. The optional third argument should be a a parameterized block as produced by the puppet syntax:
+
+      $a.slice($n) |$x| { ... }
+      slice($a) |$x| { ... }
+
+  The parameterized block should have either one parameter (receiving an array with the slice), or the same number
+  of parameters as specified by the slice size (each parameter receiving its part of the slice).
+  In case there are fewer remaining elements than the slice size for the last slice it will contain the remaining
+  elements. When the block has multiple parameters, excess parameters are set to :undef for an array or
+  enumerable type, and to empty arrays for a Hash.
+
+      $a.slice(2) |$first, $second| { ... }
+
+  When the first argument is a Hash, each `key,value` entry is counted as one, e.g, a slice size of 2 will produce
+  an array of two arrays with key, and value.
+
+      $a.slice(2) |$entry|          { notice "first ${$entry[0]}, second ${$entry[1]}" }
+      $a.slice(2) |$first, $second| { notice "first ${first}, second ${second}" }
+
+  When called without a block, the function produces a concatenated result of the slices.
+
+      slice([1,2,3,4,5,6], 2) # produces [[1,2], [3,4], [5,6]]
+      slice(Integer[1,6], 2)  # produces [[1,2], [3,4], [5,6]]
+      slice(4,2)              # produces [[0,1], [2,3]]
+      slice('hello',2)        # produces [[h, e], [l, l], [o]]
+
+  - Since 3.2 for Array and Hash
+  - Since 3.5 for additional enumerable types
+  - requires `parser = future`.
+  ENDHEREDOC
+  require 'puppet/parser/ast/lambda'
+  require 'puppet/parser/scope'
+
+  def each_Common(o, slice_size, filler, scope, pblock)
+    serving_size = pblock ? pblock.parameter_count : 1
+    if serving_size == 0
+      raise ArgumentError, "slice(): block must define at least one parameter. Block has 0."
+    end
+    unless serving_size == 1 || serving_size == slice_size
+      raise ArgumentError, "slice(): block must define one parameter, or " +
+        "the same number of parameters as the given size of the slice (#{slice_size}). Block has #{serving_size}; "+
+      pblock.parameter_names.join(', ')
+    end
+    enumerator = o.each_slice(slice_size)
+    result = []
+    if serving_size == 1
+      begin
+        if pblock
+          loop do
+            pblock.call(scope, enumerator.next)
+          end
+        else
+          loop do
+            result << enumerator.next
+          end
+        end
+      rescue StopIteration
+      end
+    else
+      begin
+        loop do
+          a = enumerator.next
+          if a.size < serving_size
+            a = a.dup.fill(filler, a.length...serving_size)
+          end
+          pblock.call(scope, *a)
+        end
+      rescue StopIteration
+      end
+    end
+    if pblock
+      o
+    else
+      result
+    end
+  end
+
+  raise ArgumentError, ("slice(): wrong number of arguments (#{args.length}; must be 2 or 3)") unless args.length == 2 || args.length == 3
+  if args.length >= 2
+    begin
+      slice_size = Puppet::Parser::Scope.number?(args[1])
+    rescue
+      raise ArgumentError, ("slice(): wrong argument type (#{args[1]}; must be number.")
+    end
+  end
+  raise ArgumentError, ("slice(): wrong argument type (#{args[1]}; must be number.") unless slice_size
+  raise ArgumentError, ("slice(): wrong argument value: #{slice_size}; is not a positive integer number > 0") unless slice_size.is_a?(Fixnum) && slice_size > 0
+  receiver = args[0]
+
+  # the block is optional, ok if nil, function then produces an array
+  pblock = args[2]
+  raise ArgumentError, ("slice(): wrong argument type (#{args[2].class}; must be a parameterized block.") unless pblock.respond_to?(:puppet_lambda) || args.length == 2
+
+  case receiver
+  when Hash
+    each_Common(receiver, slice_size, [], self, pblock)
+  else
+    enum = Puppet::Pops::Types::Enumeration.enumerator(receiver)
+    if enum.nil?
+      raise ArgumentError, ("slice(): given type '#{tc.string(receiver)}' is not enumerable")
+    end
+    result = each_Common(enum, slice_size, :undef, self, pblock)
+    pblock ? receiver : result
+  end
+end

data/lib/puppet/parser/functions/split.rb

@@ -0,0 +1,28 @@
+module Puppet::Parser::Functions
+
+  newfunction(
+  :split, :type => :rvalue,
+  :arity => 2,
+
+    :doc => "\
+Split a string variable into an array using the specified split regexp.
+
+*Example:*
+
+    $string     = 'v1.v2:v3.v4'
+    $array_var1 = split($string, ':')
+    $array_var2 = split($string, '[.]')
+    $array_var3 = split($string, '[.:]')
+
+`$array_var1` now holds the result `['v1.v2', 'v3.v4']`,
+while `$array_var2` holds `['v1', 'v2:v3', 'v4']`, and
+`$array_var3` holds `['v1', 'v2', 'v3', 'v4']`.
+
+Note that in the second example, we split on a literal string that contains
+a regexp meta-character (.), which must be escaped.  A simple
+way to do that for a single character is to enclose it in square
+brackets; a backslash will also escape a single character.") do |args|
+
+  return args[0].split(Regexp.compile(args[1]))
+  end
+end

data/lib/puppet/parser/functions/sprintf.rb

@@ -0,0 +1,36 @@
+# Copyright (C) 2009 Thomas Bellman
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THOMAS BELLMAN BE LIABLE FOR ANY CLAIM, DAMAGES OR
+# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.
+#
+# Except as contained in this notice, the name of Thomas Bellman shall
+# not be used in advertising or otherwise to promote the sale, use or
+# other dealings in this Software without prior written authorization
+# from Thomas Bellman.
+
+Puppet::Parser::Functions::newfunction(
+  :sprintf, :type => :rvalue,
+  :arity => -2,
+  :doc => "Perform printf-style formatting of text.
+
+      The first parameter is format string describing how the rest of the parameters should be formatted.  See the documentation for the `Kernel::sprintf` function in Ruby for all the details."
+) do |args|
+  fmt = args.shift
+  return sprintf(fmt, *args)
+end

data/lib/puppet/parser/functions/tag.rb

@@ -0,0 +1,6 @@
+# Tag the current scope with each passed name
+Puppet::Parser::Functions::newfunction(:tag, :arity => -2, :doc => "Add the specified tags to the containing class
+  or definition.  All contained objects will then acquire that tag, also.
+  ") do |vals|
+    self.resource.tag(*vals)
+end

data/lib/puppet/parser/functions/tagged.rb

@@ -0,0 +1,18 @@
+# Test whether a given tag is set.  This functions as a big OR -- if any of the specified tags are unset, we return false.
+Puppet::Parser::Functions::newfunction(:tagged, :type => :rvalue, :arity => -2, :doc => "A boolean function that
+  tells you whether the current container is tagged with the specified tags.
+  The tags are ANDed, so that all of the specified tags must be included for
+  the function to return true.") do |vals|
+    configtags = compiler.catalog.tags
+    resourcetags = resource.tags
+
+    retval = true
+    vals.each do |val|
+      unless configtags.include?(val) or resourcetags.include?(val)
+        retval = false
+        break
+      end
+    end
+
+    return retval
+end

data/lib/puppet/parser/functions/template.rb

@@ -0,0 +1,23 @@
+Puppet::Parser::Functions::newfunction(:template, :type => :rvalue, :arity => -2, :doc =>
+  "Evaluate a template and return its value.  See
+  [the templating docs](http://docs.puppetlabs.com/guides/templating.html) for
+  more information.
+
+  Note that if multiple templates are specified, their output is all
+  concatenated and returned as the output of the function.") do |vals|
+    vals.collect do |file|
+      # Use a wrapper, so the template can't get access to the full
+      # Scope object.
+      debug "Retrieving template #{file}"
+
+      wrapper = Puppet::Parser::TemplateWrapper.new(self)
+      wrapper.file = file
+      begin
+        wrapper.result
+      rescue => detail
+        info = detail.backtrace.first.split(':')
+        raise Puppet::ParseError,
+          "Failed to parse template #{file}:\n  Filepath: #{info[0]}\n  Line: #{info[1]}\n  Detail: #{detail}\n"
+      end
+    end.join("")
+end

data/lib/puppet/parser/functions/versioncmp.rb

@@ -0,0 +1,30 @@
+require 'puppet/util/package'
+
+Puppet::Parser::Functions::newfunction( :versioncmp, :type => :rvalue, :arity => 2, :doc =>
+"Compares two version numbers.
+
+Prototype:
+
+    \$result = versioncmp(a, b)
+
+Where a and b are arbitrary version strings.
+
+This function returns:
+
+* `1` if version a is greater than version b
+* `0` if the versions are equal
+* `-1` if version a is less than version b
+
+Example:
+
+    if versioncmp('2.6-1', '2.4.5') > 0 {
+        notice('2.6-1 is > than 2.4.5')
+    }
+
+This function uses the same version comparison algorithm used by Puppet's
+`package` type.
+
+") do |args|
+
+  return Puppet::Util::Package.versioncmp(args[0], args[1])
+end

data/lib/puppet/parser/grammar.ra

@@ -0,0 +1,806 @@
+# vim: syntax=ruby
+
+# the parser
+
+class Puppet::Parser::Parser
+
+token STRING DQPRE DQMID DQPOST
+token LBRACK  RBRACK LBRACE RBRACE SYMBOL FARROW COMMA TRUE
+token FALSE EQUALS APPENDS LESSEQUAL NOTEQUAL DOT COLON LLCOLLECT RRCOLLECT
+token QMARK LPAREN RPAREN ISEQUAL GREATEREQUAL GREATERTHAN LESSTHAN
+token IF ELSE IMPORT DEFINE ELSIF VARIABLE CLASS INHERITS NODE BOOLEAN
+token NAME SEMIC CASE DEFAULT AT LCOLLECT RCOLLECT CLASSREF
+token NOT OR AND UNDEF PARROW PLUS MINUS TIMES DIV LSHIFT RSHIFT UMINUS
+token MATCH NOMATCH REGEX IN_EDGE OUT_EDGE IN_EDGE_SUB OUT_EDGE_SUB
+token IN UNLESS MODULO
+
+prechigh
+  right NOT
+  nonassoc UMINUS
+  left  IN MATCH NOMATCH
+  left  TIMES DIV MODULO
+  left  MINUS PLUS
+  left  LSHIFT RSHIFT
+  left  NOTEQUAL ISEQUAL
+  left  GREATEREQUAL GREATERTHAN LESSTHAN LESSEQUAL
+  left  AND
+  left  OR
+preclow
+
+rule
+program:    statements_and_declarations
+  | nil
+
+  statements_and_declarations:   statement_or_declaration {
+    result = ast AST::BlockExpression, :children => (val[0] ? [val[0]] : [])
+  }
+  | statements_and_declarations statement_or_declaration {
+    if val[1]
+      val[0].push(val[1])
+    end
+    result = val[0]
+  }
+
+# statements is like statements_and_declarations, but it doesn't allow
+# nested definitions, classes, or nodes.
+statements: statements_and_declarations {
+  val[0].each do |stmt|
+    if stmt.is_a?(AST::TopLevelConstruct)
+      error "Classes, definitions, and nodes may only appear at toplevel or inside other classes", \
+          :line => stmt.context[:line], :file => stmt.context[:file]
+    end
+  end
+  result = val[0]
+}
+
+# The main list of valid statements
+statement_or_declaration:    resource
+  | virtualresource
+  | collection
+  | assignment
+  | casestatement
+  | ifstatement_begin
+  | unlessstatement
+  | import
+  | fstatement
+  | definition
+  | hostclass
+  | nodedef
+  | resourceoverride
+  | append
+  | relationship
+
+keyword: AND
+ | CASE
+ | CLASS
+ | DEFAULT
+ | DEFINE
+ | ELSE
+ | ELSIF
+ | IF
+ | IN
+ | IMPORT
+ | INHERITS
+ | NODE
+ | OR
+ | UNDEF
+ | UNLESS
+
+relationship: relationship_side edge relationship_side {
+  result = AST::Relationship.new(val[0], val[2], val[1][:value], ast_context)
+}
+  | relationship edge relationship_side {
+    result = AST::Relationship.new(val[0], val[2], val[1][:value], ast_context)
+}
+
+relationship_side: resource
+  | resourceref
+  | collection
+  | variable
+  | quotedtext
+  | selector
+  | casestatement
+  | hasharrayaccesses
+
+edge: IN_EDGE | OUT_EDGE | IN_EDGE_SUB | OUT_EDGE_SUB
+
+fstatement:   NAME LPAREN expressions RPAREN {
+  result = ast AST::Function,
+    :name => val[0][:value],
+    :line => val[0][:line],
+    :arguments => val[2],
+    :ftype => :statement
+}
+| NAME LPAREN expressions COMMA RPAREN {
+  result = ast AST::Function,
+    :name => val[0][:value],
+    :line => val[0][:line],
+    :arguments => val[2],
+    :ftype => :statement
+}            | NAME LPAREN RPAREN {
+  result = ast AST::Function,
+    :name => val[0][:value],
+    :line => val[0][:line],
+    :arguments => AST::ASTArray.new({}),
+    :ftype => :statement
+}
+  | NAME funcvalues {
+    result = ast AST::Function,
+    :name => val[0][:value],
+    :line => val[0][:line],
+    :arguments => val[1],
+    :ftype => :statement
+}
+
+funcvalues: rvalue { result = aryfy(val[0]) }
+# This rvalue could be an expression
+  | funcvalues COMMA rvalue {
+    val[0].push(val[2])
+    result = val[0]
+}
+
+expressions: expression               { result = aryfy(val[0]) }
+       | expressions comma expression { result = val[0].push(val[2]) }
+
+rvalue:       quotedtext
+  | name
+  | type
+  | boolean
+  | selector
+  | variable
+  | array
+  | hasharrayaccesses
+  | resourceref
+  | funcrvalue
+  | undef
+
+resource:       classname LBRACE resourceinstances endsemi RBRACE {
+  @lexer.commentpop
+  result = ast(AST::Resource, :type => val[0], :instances => val[2])
+}           | classname LBRACE params endcomma RBRACE {
+  # This is a deprecated syntax.
+  error "All resource specifications require names"
+}           | type LBRACE params endcomma RBRACE {
+  # a defaults setting for a type
+  @lexer.commentpop
+  result = ast(AST::ResourceDefaults, :type => val[0].value, :parameters => val[2])
+}
+
+# Override a value set elsewhere in the configuration.
+resourceoverride:     resourceref LBRACE anyparams endcomma RBRACE {
+  @lexer.commentpop
+  result = ast AST::ResourceOverride, :object => val[0], :parameters => val[2]
+}
+
+# Exported and virtual resources; these don't get sent to the client
+# unless they get collected elsewhere in the db.
+virtualresource:  at resource {
+  type = val[0]
+
+  if (type == :exported and ! Puppet[:storeconfigs])
+    Puppet.warning addcontext("You cannot collect without storeconfigs being set")
+  end
+
+  error "Defaults are not virtualizable" if val[1].is_a? AST::ResourceDefaults
+
+  method = type.to_s + "="
+
+  # Just mark our resource as exported and pass it through.
+  val[1].send(method, true)
+
+  result = val[1]
+}
+
+at:   AT { result = :virtual }
+  | AT AT { result = :exported }
+
+# A collection statement.  Currently supports no arguments at all, but eventually
+# will, I assume.
+collection:     type collectrhand LBRACE anyparams endcomma RBRACE {
+  @lexer.commentpop
+  type = val[0].value.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]
+    Puppet.warning addcontext("You cannot collect exported resources without storeconfigs being set; the collection will be ignored")
+  end
+  args[:override] = val[3]
+  result = ast AST::Collection, args
+}
+  | type collectrhand {
+  type = val[0].value.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]
+    Puppet.warning addcontext("You cannot collect exported resources without storeconfigs being set; the collection will be ignored")
+  end
+  result = ast AST::Collection, args
+}
+
+
+collectrhand:     LCOLLECT collstatements RCOLLECT {
+  if val[1]
+    result = val[1]
+    result.form = :virtual
+  else
+    result = :virtual
+  end
+}
+  | LLCOLLECT collstatements RRCOLLECT {
+    if val[1]
+    result = val[1]
+    result.form = :exported
+  else
+    result = :exported
+  end
+}
+
+# A mini-language for handling collection comparisons.  This is organized
+# to avoid the need for precedence indications.
+collstatements:           nil
+  | collstatement
+  | collstatements colljoin collstatement {
+    result = ast AST::CollExpr, :test1 => val[0], :oper => val[1], :test2 => val[2]
+}
+
+collstatement:            collexpr
+  | LPAREN collstatements RPAREN {
+    result = val[1]
+    result.parens = true
+}
+
+colljoin:                 AND { result=val[0][:value] }
+  | OR  { result=val[0][:value] }
+
+collexpr:                 colllval ISEQUAL expression {
+  result = ast AST::CollExpr, :test1 => val[0], :oper => val[1][:value], :test2 => val[2]
+  #result = ast AST::CollExpr
+  #result.push *val
+}
+  | colllval NOTEQUAL expression {
+    result = ast AST::CollExpr, :test1 => val[0], :oper => val[1][:value], :test2 => val[2]
+    #result = ast AST::CollExpr
+    #result.push *val
+}
+
+colllval:                 variable
+  | name
+
+resourceinst:   resourcename COLON params endcomma {
+  result = ast AST::ResourceInstance, :title => val[0], :parameters => val[2]
+}
+
+resourceinstances:   resourceinst { result = aryfy(val[0]) }
+  | resourceinstances SEMIC resourceinst {
+    val[0].push val[2]
+    result = val[0]
+}
+
+endsemi:      # nothing
+  | SEMIC
+
+undef:         UNDEF {
+  result = ast AST::Undef, :value => :undef
+}
+
+name:         NAME {
+  result = ast AST::Name, :value => val[0][:value], :line => val[0][:line]
+}
+
+type:         CLASSREF {
+  result = ast AST::Type, :value => val[0][:value], :line => val[0][:line]
+}
+
+resourcename:   quotedtext
+  | name
+  | type
+  | selector
+  | variable
+  | array
+  | hasharrayaccesses
+
+assignment:     VARIABLE EQUALS expression {
+  raise Puppet::ParseError, "Cannot assign to variables in other namespaces" if val[0][:value] =~ /::/
+  # this is distinct from referencing a variable
+  variable = ast AST::Name, :value => val[0][:value], :line => val[0][:line]
+  result = ast AST::VarDef, :name => variable, :value => val[2], :line => val[0][:line]
+}
+  | hasharrayaccess EQUALS expression {
+    result = ast AST::VarDef, :name => val[0], :value => val[2]
+}
+
+append:     VARIABLE APPENDS expression {
+  variable = ast AST::Name, :value => val[0][:value], :line => val[0][:line]
+  result = ast AST::VarDef, :name => variable, :value => val[2], :append => true, :line => val[0][:line]
+}
+
+params:   # nothing
+{
+  result = ast AST::ASTArray
+}
+  | param { result = aryfy(val[0]) }
+  | params COMMA param {
+    val[0].push(val[2])
+    result = val[0]
+}
+
+param_name: NAME 
+  | keyword 
+  | BOOLEAN
+
+param:        param_name FARROW expression {
+  result = ast AST::ResourceParam, :param => val[0][:value], :line => val[0][:line], :value => val[2]
+}
+
+addparam:     NAME PARROW expression {
+  result = ast AST::ResourceParam, :param => val[0][:value], :line => val[0][:line], :value => val[2],
+    :add => true
+}
+
+anyparam:     param
+  | addparam
+
+anyparams:   # nothing
+{
+  result = ast AST::ASTArray
+}
+  | anyparam { result = aryfy(val[0]) }
+  | anyparams COMMA anyparam {
+    val[0].push(val[2])
+    result = val[0]
+}
+
+# We currently require arguments in these functions.
+funcrvalue:   NAME LPAREN expressions RPAREN {
+  result = ast AST::Function,
+    :name => val[0][:value], :line => val[0][:line],
+    :arguments => val[2],
+    :ftype => :rvalue
+}           | NAME LPAREN RPAREN {
+  result = ast AST::Function,
+    :name => val[0][:value], :line => val[0][:line],
+    :arguments => AST::ASTArray.new({}),
+    :ftype => :rvalue
+}
+
+quotedtext: STRING       { result = ast AST::String, :value => val[0][:value],                  :line => val[0][:line] }
+  | DQPRE dqrval { result = ast AST::Concat, :value => [ast(AST::String,val[0])]+val[1], :line => val[0][:line] }
+
+dqrval: expression dqtail { result = [val[0]] + val[1] }
+
+dqtail: DQPOST        { result = [ast(AST::String,val[0])]          }
+  | DQMID dqrval  { result = [ast(AST::String,val[0])] + val[1] }
+
+boolean:    BOOLEAN {
+  result = ast AST::Boolean, :value => val[0][:value], :line => val[0][:line]
+}
+
+resourceref: NAME LBRACK expressions RBRACK {
+  Puppet.warning addcontext("Deprecation notice:  Resource references should now be capitalized")
+  result = ast AST::ResourceReference, :type => val[0][:value], :line => val[0][:line], :title => val[2]
+}               | type LBRACK expressions RBRACK {
+  result = ast AST::ResourceReference, :type => val[0].value, :title => val[2]
+}
+
+unlessstatement: UNLESS expression LBRACE statements RBRACE {
+  @lexer.commentpop
+  args = {
+    :test => ast(AST::Not, :value => val[1]),
+    :statements => val[3]
+  }
+
+  result = ast AST::IfStatement, args
+}
+  | UNLESS expression LBRACE RBRACE {
+    @lexer.commentpop
+    args = {
+      :test => ast(AST::Not, :value => val[1]), 
+      :statements => ast(AST::Nop)
+    }
+    result = ast AST::IfStatement, args
+}
+
+ifstatement_begin: IF ifstatement {
+  result = val[1]
+}
+
+ifstatement:      expression LBRACE statements RBRACE else {
+  @lexer.commentpop
+  args = {
+    :test => val[0],
+    :statements => val[2]
+  }
+
+  args[:else] = val[4] if val[4]
+
+  result = ast AST::IfStatement, args
+}
+  | expression LBRACE RBRACE else {
+    @lexer.commentpop
+    args = {
+      :test => val[0],
+      :statements => ast(AST::Nop)
+  }
+
+  args[:else] = val[3] if val[3]
+
+  result = ast AST::IfStatement, args
+}
+
+else:             # nothing
+  | ELSIF ifstatement {
+    result = ast AST::Else, :statements => val[1]
+}
+  | ELSE LBRACE statements RBRACE {
+    @lexer.commentpop
+    result = ast AST::Else, :statements => val[2]
+}
+  | ELSE LBRACE RBRACE {
+    @lexer.commentpop
+    result = ast AST::Else, :statements => ast(AST::Nop)
+}
+
+# Unlike yacc/bison, it seems racc
+# gives tons of shift/reduce warnings
+# with the following syntax:
+#
+# expression: ...
+#            | expression arithop expressio { ... }
+#
+# arithop: PLUS | MINUS | DIVIDE | TIMES ...
+#
+# So I had to develop the expression by adding one rule
+# per operator :-(
+
+expression:   rvalue
+  | hash
+  | expression IN expression {
+    result = ast AST::InOperator, :lval => val[0], :rval => val[2]
+}
+  | expression MATCH regex {
+    result = ast AST::MatchOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+  | expression NOMATCH regex {
+    result = ast AST::MatchOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+  | expression PLUS expression {
+    result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+  | expression MINUS expression {
+    result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+  | expression DIV expression {
+    result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+  | expression TIMES expression {
+    result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+  | expression MODULO expression {
+    result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+  | expression LSHIFT expression {
+    result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+  | expression RSHIFT expression {
+    result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+  | MINUS expression =UMINUS {
+    result = ast AST::Minus, :value => val[1]
+}
+  | expression NOTEQUAL expression {
+    result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+  | expression ISEQUAL expression {
+    result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+  | expression GREATERTHAN expression {
+    result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+  | expression GREATEREQUAL expression {
+    result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+  | expression LESSTHAN expression {
+    result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+  | expression LESSEQUAL expression {
+    result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+  | NOT expression {
+    result = ast AST::Not, :value => val[1]
+}
+  | expression AND expression {
+    result = ast AST::BooleanOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+  | expression OR expression {
+    result = ast AST::BooleanOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+  | LPAREN expression RPAREN {
+    result = val[1]
+}
+
+casestatement:  CASE expression LBRACE caseopts RBRACE {
+  @lexer.commentpop
+  result = ast AST::CaseStatement, :test => val[1], :options => val[3]
+}
+
+caseopts:     caseopt { result = aryfy(val[0]) }
+  | caseopts caseopt {
+    val[0].push val[1]
+    result = val[0]
+}
+
+caseopt:        casevalues COLON LBRACE statements RBRACE {
+  @lexer.commentpop
+  result = ast AST::CaseOpt, :value => val[0], :statements => val[3]
+}               | casevalues COLON LBRACE RBRACE {
+  @lexer.commentpop
+
+    result = ast(
+    AST::CaseOpt,
+    :value => val[0],
+
+    :statements => ast(AST::BlockExpression)
+  )
+}
+
+casevalues:       selectlhand { result = aryfy(val[0]) }
+  | casevalues COMMA selectlhand {
+    val[0].push(val[2])
+    result = val[0]
+}
+
+selector:     selectlhand QMARK svalues {
+  result = ast AST::Selector, :param => val[0], :values => val[2]
+}
+
+svalues:      selectval
+  | LBRACE sintvalues endcomma RBRACE {
+    @lexer.commentpop
+    result = val[1]
+}
+
+sintvalues:   selectval
+  | sintvalues comma selectval {
+    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
+}
+
+selectval:        selectlhand FARROW rvalue {
+  result = ast AST::ResourceParam, :param => val[0], :value => val[2]
+}
+
+selectlhand:  name
+  | type
+  | quotedtext
+  | variable
+  | funcrvalue
+  | boolean
+  | undef
+  | hasharrayaccess
+  | DEFAULT {
+    result = ast AST::Default, :value => val[0][:value], :line => val[0][:line]
+}
+  | regex
+
+# These are only used for importing, and we don't interpolate there.
+string:        STRING       { result = [val[0][:value]] }
+strings:       string
+  |  strings COMMA string { result = val[0] += val[2] }
+
+import: IMPORT strings {
+  val[1].each do |file|
+    import(file)
+  end
+
+  result = nil
+}
+
+# Disable definition inheritance for now. 8/27/06, luke
+#definition: DEFINE NAME argumentlist parent LBRACE statements RBRACE {
+definition: DEFINE classname argumentlist LBRACE statements RBRACE {
+  @lexer.commentpop
+  result = Puppet::Parser::AST::Definition.new(classname(val[1]),
+                                               ast_context(true).merge(:arguments => val[2], :code => val[4],
+                                                                       :line => val[0][:line]))
+  @lexer.indefine = false
+
+#}           | DEFINE NAME argumentlist parent LBRACE RBRACE {
+}           | DEFINE classname argumentlist LBRACE RBRACE {
+  @lexer.commentpop
+  result = Puppet::Parser::AST::Definition.new(classname(val[1]),
+                                               ast_context(true).merge(:arguments => val[2], :line => val[0][:line]))
+  @lexer.indefine = false
+}
+
+#hostclass: CLASS NAME argumentlist parent LBRACE statements RBRACE {
+hostclass: CLASS classname argumentlist classparent LBRACE statements_and_declarations RBRACE {
+  @lexer.commentpop
+  # Our class gets defined in the parent namespace, not our own.
+  @lexer.namepop
+  result = Puppet::Parser::AST::Hostclass.new(classname(val[1]),
+                                              ast_context(true).merge(:arguments => val[2], :parent => val[3],
+                                                                      :code => val[5], :line => val[0][:line]))
+}           | CLASS classname argumentlist classparent LBRACE RBRACE {
+  @lexer.commentpop
+  # Our class gets defined in the parent namespace, not our own.
+  @lexer.namepop
+  result = Puppet::Parser::AST::Hostclass.new(classname(val[1]),
+                                              ast_context(true).merge(:arguments => val[2], :parent => val[3],
+                                                                      :line => val[0][:line]))
+}
+
+nodedef: NODE hostnames nodeparent LBRACE statements RBRACE {
+  @lexer.commentpop
+  result = Puppet::Parser::AST::Node.new(val[1],
+                                         ast_context(true).merge(:parent => val[2], :code => val[4],
+                                                                 :line => val[0][:line]))
+}       |  NODE hostnames nodeparent LBRACE RBRACE {
+  @lexer.commentpop
+  result = Puppet::Parser::AST::Node.new(val[1], ast_context(true).merge(:parent => val[2], :line => val[0][:line]))
+}
+
+classname:      NAME { result = val[0][:value] }
+  | CLASS { result = "class" }
+
+# Multiple hostnames, as used for node names.  These are all literal
+# strings, not AST objects.
+hostnames:    nodename {
+    result = [result]
+}
+  | hostnames COMMA nodename {
+    result = val[0]
+    result << val[2]
+}
+
+nodename: hostname {
+  result = ast AST::HostName, :value => val[0]
+}
+
+hostname: NAME { result = val[0][:value] }
+  | STRING { result = val[0][:value] }
+  | DEFAULT { result = val[0][:value] }
+  | regex
+
+nil:    {
+  result = nil
+}
+
+nothing:    {
+  result = ast AST::ASTArray, :children => []
+}
+
+argumentlist: nil
+  | LPAREN nothing RPAREN {
+    result = nil
+}
+  | LPAREN arguments endcomma RPAREN {
+    result = val[1]
+    result = [result] unless result[0].is_a?(Array)
+}
+
+arguments:    argument
+  | arguments COMMA argument {
+    result = val[0]
+    result = [result] unless result[0].is_a?(Array)
+    result << val[2]
+}
+
+argument:
+ VARIABLE EQUALS expression { result = [val[0][:value], val[2]] }
+| VARIABLE { result = [val[0][:value]] }
+
+nodeparent:       nil
+  | INHERITS hostname {
+    result = val[1]
+}
+
+classparent:       nil
+  | INHERITS classnameordefault {
+    result = val[1]
+}
+
+classnameordefault: classname | DEFAULT
+
+variable:     VARIABLE {
+  result = ast AST::Variable, :value => val[0][:value], :line => val[0][:line]
+}
+
+array: LBRACK expressions       RBRACK { result = val[1] }
+     | LBRACK expressions COMMA RBRACK { result = val[1] }
+     | LBRACK               RBRACK { result = ast AST::ASTArray }
+
+comma:        FARROW
+  | COMMA
+
+endcomma:     # nothing
+  | COMMA { result = nil }
+
+regex:        REGEX {
+  result = ast AST::Regex, :value => val[0][:value]
+}
+
+hash:        LBRACE hashpairs RBRACE {
+  @lexer.commentpop
+  if val[1].instance_of?(AST::ASTHash)
+    result = val[1]
+  else
+    result = ast AST::ASTHash, { :value => val[1] }
+  end
+}
+  | LBRACE hashpairs COMMA RBRACE {
+    @lexer.commentpop
+    if val[1].instance_of?(AST::ASTHash)
+    result = val[1]
+  else
+    result = ast AST::ASTHash, { :value => val[1] }
+  end
+}           | LBRACE RBRACE {
+  @lexer.commentpop
+  result = ast AST::ASTHash
+}
+
+hashpairs:  hashpair
+  | hashpairs COMMA hashpair {
+    if val[0].instance_of?(AST::ASTHash)
+    result = val[0].merge(val[2])
+  else
+    result = ast AST::ASTHash, :value => val[0]
+    result.merge(val[2])
+  end
+}
+
+hashpair:   key FARROW expression {
+  result = ast AST::ASTHash, { :value => { val[0] => val[2] } }
+}
+
+key:      NAME { result = val[0][:value] }
+  | quotedtext { result = val[0] }
+
+hasharrayaccess: VARIABLE LBRACK expression RBRACK {
+  result = ast AST::HashOrArrayAccess, :variable => val[0][:value], :key => val[2]
+}
+
+hasharrayaccesses:    hasharrayaccess
+  | hasharrayaccesses LBRACK expression RBRACK {
+    result = ast AST::HashOrArrayAccess, :variable => val[0], :key => val[2]
+}
+
+end
+---- header ----
+require 'puppet'
+require 'puppet/parser/lexer'
+require 'puppet/parser/ast'
+
+module Puppet
+  class ParseError < Puppet::Error; end
+  class ImportError < Racc::ParseError; end
+  class AlreadyImportedError < ImportError; end
+end
+
+---- inner ----
+
+# It got too annoying having code in a file that needs to be compiled.
+require 'puppet/parser/parser_support'
+
+# Make emacs happy
+# Local Variables:
+# mode: ruby
+# End: