From 6dbd4771265173a9d4c3e7756c35c9ca371ca394 Mon Sep 17 00:00:00 2001 From: Jesse Wolfe Date: Wed, 28 Jul 2010 14:54:23 -0700 Subject: [#4397]+[#4344] Move type-name resolution out of Puppet::Resource into the AST resources. Move type-name resolution out of Puppet::Resource into the AST resources. Move find_resource_type out of Puppet::Resource into Scope Thus, never pass unqualified type names to Puppet::Resource objects. Thus, Puppet::Resource objects don't need the namespace property, and Puppet::Resource objects never consult the harddrive to look for .pp files that might contain their type definitions, Thus, performance is improved. Also removes the temporary fix for #4257 that caused #4397 (The code was too eager to look for a class in the topscope) Paired-With: Paul Berry Signed-off-by: Jesse Wolfe --- lib/puppet/parser/ast/resource.rb | 6 +- lib/puppet/parser/ast/resource_reference.rb | 25 +++++- lib/puppet/parser/resource.rb | 6 +- lib/puppet/parser/scope.rb | 14 +++ lib/puppet/resource.rb | 128 +++------------------------- lib/puppet/resource/type_collection.rb | 8 +- 6 files changed, 57 insertions(+), 130 deletions(-) (limited to 'lib') diff --git a/lib/puppet/parser/ast/resource.rb b/lib/puppet/parser/ast/resource.rb index 1b063c984..9149b06c3 100644 --- a/lib/puppet/parser/ast/resource.rb +++ b/lib/puppet/parser/ast/resource.rb @@ -33,11 +33,11 @@ class Resource < AST::ResourceReference # This is where our implicit iteration takes place; if someone # passed an array as the name, then we act just like the called us # many times. + resource_type = scope.find_resource_type(type) resource_titles.flatten.collect { |resource_title| exceptwrap :type => Puppet::ParseError do - - resource = Puppet::Parser::Resource.new( - type, resource_title, + resource = Puppet::Parser::Resource.new( + resource_type.name, resource_title, :parameters => paramobjects, :file => self.file, :line => self.line, diff --git a/lib/puppet/parser/ast/resource_reference.rb b/lib/puppet/parser/ast/resource_reference.rb index 5d8334335..5b1b0aa3a 100644 --- a/lib/puppet/parser/ast/resource_reference.rb +++ b/lib/puppet/parser/ast/resource_reference.rb @@ -7,8 +7,29 @@ class Puppet::Parser::AST::ResourceReference < Puppet::Parser::AST::Branch # Evaluate our object, but just return a simple array of the type # and name. def evaluate(scope) - titles = Array(title.safeevaluate(scope)).collect { |t| Puppet::Resource.new(type, t, :namespaces => scope.namespaces) } - return(titles.length == 1 ? titles.pop : titles) + a_type = type + titles = Array(title.safeevaluate(scope)) + + case type.downcase + when "class" + # resolve the titles + titles = titles.collect do |a_title| + hostclass = scope.find_hostclass(a_title) + hostclass ? hostclass.name : a_title + end + when "node" + # no-op + else + # resolve the type + resource_type = scope.find_resource_type(type) + a_type = resource_type.name if resource_type + end + + resources = titles.collect{ |a_title| + Puppet::Resource.new(a_type, a_title) + } + + return(resources.length == 1 ? resources.pop : resources) end def to_s diff --git a/lib/puppet/parser/resource.rb b/lib/puppet/parser/resource.rb index 3c451929e..8a5ae886c 100644 --- a/lib/puppet/parser/resource.rb +++ b/lib/puppet/parser/resource.rb @@ -102,9 +102,9 @@ class Puppet::Parser::Resource < Puppet::Resource end def initialize(*args) + raise ArgumentError, "Resources require a scope" unless args.last[:scope] super - raise ArgumentError, "Resources require a scope" unless scope @source ||= scope.source end @@ -140,10 +140,6 @@ class Puppet::Parser::Resource < Puppet::Resource self[:name] || self.title end - def namespaces - scope.namespaces - end - # A temporary occasion, until I get paths in the scopes figured out. def path to_s diff --git a/lib/puppet/parser/scope.rb b/lib/puppet/parser/scope.rb index ae0f9ea4a..2ca28d824 100644 --- a/lib/puppet/parser/scope.rb +++ b/lib/puppet/parser/scope.rb @@ -474,6 +474,20 @@ class Puppet::Parser::Scope end end + def find_resource_type(type) + # It still works fine without the type == 'class' short-cut, but it is a lot slower. + return nil if ["class", "node"].include? type.to_s.downcase + find_builtin_resource_type(type) || find_defined_resource_type(type) + end + + def find_builtin_resource_type(type) + Puppet::Type.type(type.to_s.downcase.to_sym) + end + + def find_defined_resource_type(type) + environment.known_resource_types.find_definition(namespaces, type.to_s.downcase) + end + private def extend_with_functions_module diff --git a/lib/puppet/resource.rb b/lib/puppet/resource.rb index 96d22e414..c4e52af18 100644 --- a/lib/puppet/resource.rb +++ b/lib/puppet/resource.rb @@ -13,7 +13,7 @@ class Puppet::Resource extend Puppet::Util::Pson include Enumerable attr_accessor :file, :line, :catalog, :exported, :virtual, :validate_parameters, :strict - attr_reader :namespaces + attr_reader :type, :title require 'puppet/indirector' extend Puppet::Indirector @@ -157,27 +157,26 @@ class Puppet::Resource # Create our resource. def initialize(type, title = nil, attributes = {}) @parameters = {} - @namespaces = [""] - # Set things like namespaces and strictness first. + # Set things like strictness first. attributes.each do |attr, value| next if attr == :parameters send(attr.to_s + "=", value) end - # We do namespaces first, and use tmp variables, so our title - # canonicalization works (i.e., namespaces are set and resource - # types can be looked up) - tmp_type, tmp_title = extract_type_and_title(type, title) - self.type = tmp_type - self.title = tmp_title + @type, @title = extract_type_and_title(type, title) + + @type = munge_type_name(@type) + + if @type == "Class" + @title = :main if @title == "" + @title = munge_type_name(@title) + end if params = attributes[:parameters] extract_parameters(params) end - resolve_type_and_title - tag(self.type) tag(self.title) if valid_tag?(self.title) @@ -193,17 +192,12 @@ class Puppet::Resource return(catalog ? catalog.resource(to_s) : nil) end - def title=(value) - @unresolved_title = value - @title = nil - end - def resource_type @resource_type ||= case type - when "Class"; find_hostclass(title) - when "Node"; find_node(title) + when "Class"; known_resource_types.hostclass(title == :main ? "" : title) + when "Node"; known_resource_types.node(title) else - find_resource_type(type) + Puppet::Type.type(type.to_s.downcase.to_sym) || known_resource_types.definition(type) end end @@ -314,28 +308,6 @@ class Puppet::Resource self end - # We have to lazy-evaluate this. - def title=(value) - @title = nil - @unresolved_title = value - end - - # We have to lazy-evaluate this. - def type=(value) - @type = nil - @unresolved_type = value || "Class" - end - - def title - resolve_type_and_title unless @title - @title - end - - def type - resolve_type_and_title unless @type - @type - end - def valid_parameter?(name) resource_type.valid_parameter?(name) end @@ -346,29 +318,6 @@ class Puppet::Resource private - def find_node(name) - known_resource_types.node(name) - end - - def find_hostclass(title) - name = title == :main ? "" : title - known_resource_types.find_hostclass(namespaces, name) - end - - def find_resource_type(type) - # It still works fine without the type == 'class' short-cut, but it is a lot slower. - return nil if ["class", "node"].include? type.to_s.downcase - find_builtin_resource_type(type) || find_defined_resource_type(type) - end - - def find_builtin_resource_type(type) - Puppet::Type.type(type.to_s.downcase.to_sym) - end - - def find_defined_resource_type(type) - known_resource_types.find_definition(namespaces, type.to_s.downcase) - end - # Produce a canonical method name. def parameter_name(param) param = param.to_s.downcase.to_sym @@ -378,10 +327,6 @@ class Puppet::Resource param end - def namespaces=(ns) - @namespaces = Array(ns) - end - # The namevar for our resource type. If the type doesn't exist, # always use :name. def namevar @@ -428,54 +373,9 @@ class Puppet::Resource value.to_s.split("::").collect { |s| s.capitalize }.join("::") end - # This is an annoyingly complicated method for resolving qualified - # types as necessary, and putting them in type or title attributes. - def resolve_type_and_title - if @unresolved_type - @type = resolve_type - @unresolved_type = nil - end - if @unresolved_title - @title = resolve_title - @unresolved_title = nil - end - end - - def resolve_type - case type = munge_type_name(@unresolved_type) - when "Class", "Node"; - type - else - # Otherwise, some kind of builtin or defined resource type - munge_type_name( (r = find_resource_type(type)) ? r.name : type) - end - end - - # This method only works if resolve_type was called first - def resolve_title - case @type - when "Node"; return @unresolved_title - when "Class"; - resolve_title_for_class(@unresolved_title) - else - @unresolved_title - end - end - - def resolve_title_for_class(title) - if title == "" or title == :main - return :main - end - - if klass = find_hostclass(title) - result = klass.name - end - munge_type_name(result || title) - end - def parse_title h = {} - type = find_resource_type(@type) + type = resource_type if type.respond_to? :title_patterns type.title_patterns.each { |regexp, symbols_and_lambdas| if captures = regexp.match(title.to_s) diff --git a/lib/puppet/resource/type_collection.rb b/lib/puppet/resource/type_collection.rb index 90b6df9c1..63d110395 100644 --- a/lib/puppet/resource/type_collection.rb +++ b/lib/puppet/resource/type_collection.rb @@ -96,8 +96,8 @@ class Puppet::Resource::TypeCollection #Array("") == [] for some reason namespaces = [namespaces] unless namespaces.is_a?(Array) - if r = find_fully_qualified(name, type) - return r + if name =~ /^::/ + return send(type, name.sub(/^::/, '')) end namespaces.each do |namespace| @@ -198,10 +198,6 @@ class Puppet::Resource::TypeCollection private - def find_fully_qualified(name, type) - send(type, name.sub(/^::/, '')) - end - def find_partially_qualified(namespace, name, type) send(type, [namespace, name].join("::")) end -- cgit From 6b1dd81799a44288287d9ab0cdf46afa3aaf090a Mon Sep 17 00:00:00 2001 From: Paul Berry Date: Thu, 5 Aug 2010 10:34:35 -0700 Subject: [#4472]+[#4483] Moved type-name resolution out of Puppet::Parser::TypeLoader. Moved type-name resolution out of Puppet::Parser::TypeLoader, and into its primary client, Puppet::Resource::TypeCollection. TypeCollection now always passes fully qualified type names to TypeLoader. This avoids duplicate type-name resolution logic between TypeLoader and TypeCollection. That in turn fixes bug 4472, which resulted from flaws in the type-name resolution logic in TypeLoader. In addition, it fixes bug 4483, which resulted from improper interleaving between looking up names using the TypeCollection and the TypeLoader. --- lib/puppet/parser/parser_support.rb | 4 +- lib/puppet/parser/type_loader.rb | 66 +++++++++++------------ lib/puppet/resource/type_collection.rb | 99 ++++++++++++++++++---------------- 3 files changed, 86 insertions(+), 83 deletions(-) (limited to 'lib') diff --git a/lib/puppet/parser/parser_support.rb b/lib/puppet/parser/parser_support.rb index c0fd37178..97d985cfb 100644 --- a/lib/puppet/parser/parser_support.rb +++ b/lib/puppet/parser/parser_support.rb @@ -103,11 +103,11 @@ class Puppet::Parser::Parser end def find_hostclass(namespace, name) - known_resource_types.find_or_load(namespace, name, :hostclass) + known_resource_types.find_hostclass(namespace, name) end def find_definition(namespace, name) - known_resource_types.find_or_load(namespace, name, :definition) + known_resource_types.find_definition(namespace, name) end def import(file) diff --git a/lib/puppet/parser/type_loader.rb b/lib/puppet/parser/type_loader.rb index 09aa636e1..516c1e32b 100644 --- a/lib/puppet/parser/type_loader.rb +++ b/lib/puppet/parser/type_loader.rb @@ -76,50 +76,29 @@ class Puppet::Parser::TypeLoader @imported = {} end - def load_until(namespaces, name) - return nil if name == "" # special-case main. - name2files(namespaces, name).each do |filename| - modname = begin - import_if_possible(filename) - rescue Puppet::ImportError => detail - # We couldn't load the item - # I'm not convienced we should just drop these errors, but this - # preserves existing behaviours. - nil - end - if result = yield(filename) - Puppet.debug "Automatically imported #{name} from #{filename} into #{environment}" - result.module_name = modname if modname and result.respond_to?(:module_name=) - return result + # Try to load the object with the given fully qualified name. For + # each file that was actually loaded, yield(filename, modname). + def try_load_fqname(fqname) + return nil if fqname == "" # special-case main. + name2files(fqname).each do |filename| + if not loaded?(filename) + modname = begin + import_if_possible(filename) + rescue Puppet::ImportError => detail + # We couldn't load the item + # I'm not convienced we should just drop these errors, but this + # preserves existing behaviours. + nil + end + yield(filename, modname) end end - nil end def loaded?(name) @loaded.include?(name) end - def name2files(namespaces, name) - return [name.sub(/^::/, '').gsub("::", File::SEPARATOR)] if name =~ /^::/ - - result = namespaces.inject([]) do |names_to_try, namespace| - fullname = (namespace + "::#{name}").sub(/^::/, '') - - # Try to load the module init file if we're a qualified name - names_to_try << fullname.split("::")[0] if fullname.include?("::") - - # Then the fully qualified name - names_to_try << fullname - end - - # Otherwise try to load the bare name on its own. This - # is appropriate if the class we're looking for is in a - # module that's different from our namespace. - result << name - result.uniq.collect { |f| f.gsub("::", File::SEPARATOR) } - end - def parse_file(file) Puppet.debug("importing '#{file}' in environment #{environment}") parser = Puppet::Parser::Parser.new(environment) @@ -143,4 +122,19 @@ class Puppet::Parser::TypeLoader @loading.done_with(file) end end + + private + + # Return a list of all file basenames that should be tried in order + # to load the object with the given fully qualified name. + def name2files(fqname) + result = [] + ary = fqname.split("::") + while ary.length > 0 + result << ary.join(File::SEPARATOR) + ary.pop + end + return result + end + end diff --git a/lib/puppet/resource/type_collection.rb b/lib/puppet/resource/type_collection.rb index 63d110395..3a327e264 100644 --- a/lib/puppet/resource/type_collection.rb +++ b/lib/puppet/resource/type_collection.rb @@ -92,50 +92,8 @@ class Puppet::Resource::TypeCollection @definitions[munge_name(name)] end - def find(namespaces, name, type) - #Array("") == [] for some reason - namespaces = [namespaces] unless namespaces.is_a?(Array) - - if name =~ /^::/ - return send(type, name.sub(/^::/, '')) - end - - namespaces.each do |namespace| - ary = namespace.split("::") - - while ary.length > 0 - tmp_namespace = ary.join("::") - if r = find_partially_qualified(tmp_namespace, name, type) - return r - end - - # Delete the second to last object, which reduces our namespace by one. - ary.pop - end - - if result = send(type, name) - return result - end - end - nil - end - - def find_or_load(namespaces, name, type) - name = name.downcase - namespaces = [namespaces] unless namespaces.is_a?(Array) - namespaces = namespaces.collect { |ns| ns.downcase } - - # This could be done in the load_until, but the knowledge seems to - # belong here. - if r = find(namespaces, name, type) - return r - end - - loader.load_until(namespaces, name) { find(namespaces, name, type) } - end - def find_node(namespaces, name) - find("", name, :node) + @nodes[munge_name(name)] end def find_hostclass(namespaces, name) @@ -198,8 +156,59 @@ class Puppet::Resource::TypeCollection private - def find_partially_qualified(namespace, name, type) - send(type, [namespace, name].join("::")) + # Return a list of all possible fully-qualified names that might be + # meant by the given name, in the context of namespaces. + def resolve_namespaces(namespaces, name) + name = name.downcase + if name =~ /^::/ + # name is explicitly fully qualified, so just return it, sans + # initial "::". + return [name.sub(/^::/, '')] + end + if name == "" + # The name "" has special meaning--it always refers to a "main" + # hostclass which contains all toplevel resources. + return [""] + end + + namespaces = [namespaces] unless namespaces.is_a?(Array) + namespaces = namespaces.collect { |ns| ns.downcase } + + result = [] + namespaces.each do |namespace| + ary = namespace.split("::") + + # Search each namespace nesting in innermost-to-outermost order. + while ary.length > 0 + result << "#{ary.join("::")}::#{name}" + ary.pop + end + + # Finally, search the toplevel namespace. + result << name + end + + return result.uniq + end + + # Resolve namespaces and find the given object. Autoload it if + # necessary. + def find_or_load(namespaces, name, type) + resolve_namespaces(namespaces, name).each do |fqname| + if result = send(type, fqname) + return result + end + loader.try_load_fqname(fqname) do |filename, modname| + if result = send(type, fqname) + Puppet.debug "Automatically imported #{name} from #{filename} into #{environment}" + result.module_name = modname if modname and result.respond_to?(:module_name=) + return result + end + end + end + + # Nothing found. + return nil end def munge_name(name) -- cgit From caca187dffbd6e628d7eda599c7f2939dd05fafc Mon Sep 17 00:00:00 2001 From: Paul Berry Date: Fri, 13 Aug 2010 15:25:17 -0700 Subject: Moved perform_initial_import from Puppet::Resource::TypeCollection to Puppet::Node::Environment. This change is part of an ongoing effort to remove functionality from TypeCollection that is not related to keeping track of a collection of types. This reduces TypeCollection's linkage to the environment, which is a step toward decoupling it from the type loading mechanism. Also, added a spec test to verify that TypeCollection.version is correctly recomputed when types are re-imported. --- lib/puppet/node/environment.rb | 22 +++++++++++++++++++++- lib/puppet/resource/type_collection.rb | 18 ------------------ 2 files changed, 21 insertions(+), 19 deletions(-) (limited to 'lib') diff --git a/lib/puppet/node/environment.rb b/lib/puppet/node/environment.rb index 3f67474f9..ad11a0476 100644 --- a/lib/puppet/node/environment.rb +++ b/lib/puppet/node/environment.rb @@ -81,7 +81,7 @@ class Puppet::Node::Environment Thread.current[:known_resource_types] ||= synchronize { if @known_resource_types.nil? or @known_resource_types.stale? @known_resource_types = Puppet::Resource::TypeCollection.new(self) - @known_resource_types.perform_initial_import + perform_initial_import end @known_resource_types } @@ -143,5 +143,25 @@ class Puppet::Node::Environment end end + private + + def perform_initial_import + return if Puppet.settings[:ignoreimport] + parser = Puppet::Parser::Parser.new(self) + if code = Puppet.settings.uninterpolated_value(:code, name.to_s) and code != "" + parser.string = code + else + file = Puppet.settings.value(:manifest, name.to_s) + return unless File.exist?(file) + parser.file = file + end + parser.parse + rescue => detail + msg = "Could not parse for environment #{self}: #{detail}" + error = Puppet::Error.new(msg) + error.set_backtrace(detail.backtrace) + raise error + end + @root = new(:'*root*') end diff --git a/lib/puppet/resource/type_collection.rb b/lib/puppet/resource/type_collection.rb index 3a327e264..4254b037e 100644 --- a/lib/puppet/resource/type_collection.rb +++ b/lib/puppet/resource/type_collection.rb @@ -110,24 +110,6 @@ class Puppet::Resource::TypeCollection end end - def perform_initial_import - return if Puppet.settings[:ignoreimport] - parser = Puppet::Parser::Parser.new(environment) - if code = Puppet.settings.uninterpolated_value(:code, environment.to_s) and code != "" - parser.string = code - else - file = Puppet.settings.value(:manifest, environment.to_s) - return unless File.exist?(file) - parser.file = file - end - parser.parse - rescue => detail - msg = "Could not parse for environment #{environment}: #{detail}" - error = Puppet::Error.new(msg) - error.set_backtrace(detail.backtrace) - raise error - end - def stale? @watched_files.values.detect { |file| file.changed? } end -- cgit From 4da88fb4cd57871f16649d50572240ac3f7420f0 Mon Sep 17 00:00:00 2001 From: Paul Berry Date: Fri, 13 Aug 2010 15:43:34 -0700 Subject: [#4496]+[#4521]+[#4522] Add structures to the AST to represent type definitions (classes, definitions, and nodes). Previously, type definitions were not represented directly in the AST. Instead, the parser would instantiate types and insert them into known_resource_types as soon as they were parsed. This made it difficult to distinguish which types had come from the file that was just parsed and which types had been loaded previously, which led to bug 4496. A side-effect of this change is that the user is no longer allowed to define types inside of conditional constructs (such as if/else). This was allowed before but had unexpected semantics (bugs 4521 and 4522). It is still possible, however, to place an "include" statement inside a conditional construct, and have that "include" statement trigger the autoloading of a file that instantiates types. --- lib/puppet/node/environment.rb | 12 +- lib/puppet/parser/ast.rb | 7 +- lib/puppet/parser/ast/astarray.rb | 19 +- lib/puppet/parser/ast/definition.rb | 12 + lib/puppet/parser/ast/hostclass.rb | 26 + lib/puppet/parser/ast/node.rb | 17 + lib/puppet/parser/ast/top_level_construct.rb | 4 + lib/puppet/parser/grammar.ra | 68 +- lib/puppet/parser/parser.rb | 2865 +++++++++++++------------- lib/puppet/parser/parser_support.rb | 91 +- lib/puppet/parser/type_loader.rb | 27 +- lib/puppet/resource/type.rb | 6 +- lib/puppet/resource/type_collection.rb | 15 +- lib/puppet/util/rdoc/parser.rb | 14 +- 14 files changed, 1666 insertions(+), 1517 deletions(-) create mode 100644 lib/puppet/parser/ast/definition.rb create mode 100644 lib/puppet/parser/ast/hostclass.rb create mode 100644 lib/puppet/parser/ast/node.rb create mode 100644 lib/puppet/parser/ast/top_level_construct.rb (limited to 'lib') diff --git a/lib/puppet/node/environment.rb b/lib/puppet/node/environment.rb index ad11a0476..3d55ac1a0 100644 --- a/lib/puppet/node/environment.rb +++ b/lib/puppet/node/environment.rb @@ -81,7 +81,7 @@ class Puppet::Node::Environment Thread.current[:known_resource_types] ||= synchronize { if @known_resource_types.nil? or @known_resource_types.stale? @known_resource_types = Puppet::Resource::TypeCollection.new(self) - perform_initial_import + @known_resource_types.import_ast(perform_initial_import, '') end @known_resource_types } @@ -146,13 +146,13 @@ class Puppet::Node::Environment private def perform_initial_import - return if Puppet.settings[:ignoreimport] + return empty_parse_result if Puppet.settings[:ignoreimport] parser = Puppet::Parser::Parser.new(self) if code = Puppet.settings.uninterpolated_value(:code, name.to_s) and code != "" parser.string = code else file = Puppet.settings.value(:manifest, name.to_s) - return unless File.exist?(file) + return empty_parse_result unless File.exist?(file) parser.file = file end parser.parse @@ -163,5 +163,11 @@ class Puppet::Node::Environment raise error end + def empty_parse_result + # Return an empty toplevel hostclass to use as the result of + # perform_initial_import when no file was actually loaded. + return Puppet::Parser::AST::Hostclass.new('') + end + @root = new(:'*root*') end diff --git a/lib/puppet/parser/ast.rb b/lib/puppet/parser/ast.rb index 54e034acb..0369a6d28 100644 --- a/lib/puppet/parser/ast.rb +++ b/lib/puppet/parser/ast.rb @@ -107,22 +107,26 @@ end require 'puppet/parser/ast/arithmetic_operator' require 'puppet/parser/ast/astarray' require 'puppet/parser/ast/asthash' -require 'puppet/parser/ast/branch' require 'puppet/parser/ast/boolean_operator' +require 'puppet/parser/ast/branch' require 'puppet/parser/ast/caseopt' require 'puppet/parser/ast/casestatement' require 'puppet/parser/ast/collection' require 'puppet/parser/ast/collexpr' require 'puppet/parser/ast/comparison_operator' +require 'puppet/parser/ast/definition' require 'puppet/parser/ast/else' require 'puppet/parser/ast/function' +require 'puppet/parser/ast/hostclass' require 'puppet/parser/ast/ifstatement' require 'puppet/parser/ast/in_operator' require 'puppet/parser/ast/leaf' require 'puppet/parser/ast/match_operator' require 'puppet/parser/ast/minus' +require 'puppet/parser/ast/node' require 'puppet/parser/ast/nop' require 'puppet/parser/ast/not' +require 'puppet/parser/ast/relationship' require 'puppet/parser/ast/resource' require 'puppet/parser/ast/resource_defaults' require 'puppet/parser/ast/resource_override' @@ -131,4 +135,3 @@ require 'puppet/parser/ast/resourceparam' require 'puppet/parser/ast/selector' require 'puppet/parser/ast/tag' require 'puppet/parser/ast/vardef' -require 'puppet/parser/ast/relationship' diff --git a/lib/puppet/parser/ast/astarray.rb b/lib/puppet/parser/ast/astarray.rb index 529998e3c..432300c7a 100644 --- a/lib/puppet/parser/ast/astarray.rb +++ b/lib/puppet/parser/ast/astarray.rb @@ -9,6 +9,11 @@ class Puppet::Parser::AST class ASTArray < Branch include Enumerable + # True if this ASTArray represents a list of statements in a + # context that defines a namespace. Classes and definitions may + # only appear in such a context. + attr_accessor :is_a_namespace + # Return a child by index. Probably never used. def [](index) @children[index] @@ -32,7 +37,19 @@ class Puppet::Parser::AST } rets = items.flatten.collect { |child| - child.safeevaluate(scope) + if child.respond_to? :instantiate + if is_a_namespace + # no problem, just don't evaluate it. + else + msg = "Classes, definitions, and nodes may only appear at toplevel or inside other classes" + error = Puppet::Error.new(msg) + error.line = child.line + error.file = child.file + raise error + end + else + child.safeevaluate(scope) + end } rets.reject { |o| o.nil? } end diff --git a/lib/puppet/parser/ast/definition.rb b/lib/puppet/parser/ast/definition.rb new file mode 100644 index 000000000..09f52b519 --- /dev/null +++ b/lib/puppet/parser/ast/definition.rb @@ -0,0 +1,12 @@ +require 'puppet/parser/ast/top_level_construct' + +class Puppet::Parser::AST::Definition < Puppet::Parser::AST::TopLevelConstruct + def initialize(name, context = {}) + @name = name + @context = context + end + + def instantiate(modname) + return [Puppet::Resource::Type.new(:definition, @name, @context.merge(:module_name => modname))] + end +end diff --git a/lib/puppet/parser/ast/hostclass.rb b/lib/puppet/parser/ast/hostclass.rb new file mode 100644 index 000000000..d539e4deb --- /dev/null +++ b/lib/puppet/parser/ast/hostclass.rb @@ -0,0 +1,26 @@ +require 'puppet/parser/ast/top_level_construct' + +class Puppet::Parser::AST::Hostclass < Puppet::Parser::AST::TopLevelConstruct + attr_accessor :name, :context + + def initialize(name, context = {}) + @context = context + @name = name + end + + def instantiate(modname) + all_types = [Puppet::Resource::Type.new(:hostclass, @name, @context.merge(:module_name => modname))] + if code + code.each do |nested_ast_node| + if nested_ast_node.respond_to? :instantiate + all_types += nested_ast_node.instantiate(modname) + end + end + end + return all_types + end + + def code() + @context[:code] + end +end diff --git a/lib/puppet/parser/ast/node.rb b/lib/puppet/parser/ast/node.rb new file mode 100644 index 000000000..c19a24ce0 --- /dev/null +++ b/lib/puppet/parser/ast/node.rb @@ -0,0 +1,17 @@ +require 'puppet/parser/ast/top_level_construct' + +class Puppet::Parser::AST::Node < Puppet::Parser::AST::TopLevelConstruct + attr_accessor :names + + def initialize(names, context = {}) + raise ArgumentError, "names should be an array" unless names.is_a? Array + @names = names + @context = context + end + + def instantiate(modname) + @names.collect do |name| + Puppet::Resource::Type.new(:node, name, @context.merge(:module_name => modname)) + end + end +end diff --git a/lib/puppet/parser/ast/top_level_construct.rb b/lib/puppet/parser/ast/top_level_construct.rb new file mode 100644 index 000000000..901a939c2 --- /dev/null +++ b/lib/puppet/parser/ast/top_level_construct.rb @@ -0,0 +1,4 @@ +# The base class for AST nodes representing top level things: +# hostclasses, definitions, and nodes. +class Puppet::Parser::AST::TopLevelConstruct < Puppet::Parser::AST +end diff --git a/lib/puppet/parser/grammar.ra b/lib/puppet/parser/grammar.ra index 7a316d4d7..3185c435d 100644 --- a/lib/puppet/parser/grammar.ra +++ b/lib/puppet/parser/grammar.ra @@ -29,37 +29,18 @@ preclow rule program: statements { - 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 + val[0].is_a_namespace = true + result = val[0] } | nil -statements: statement + statements: statement { + result = ast AST::ASTArray, :children => [val[0]] + } | statements statement { - 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 -} + val[0].push(val[1]) + result = val[0] + } # The main list of valid statements statement: resource @@ -664,16 +645,17 @@ import: IMPORT strings { #definition: DEFINE NAME argumentlist parent LBRACE statements RBRACE { definition: DEFINE classname argumentlist LBRACE statements RBRACE { @lexer.commentpop - newdefine classname(val[1]), :arguments => val[2], :code => val[4], :line => val[0][:line] + 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 - result = nil #} | DEFINE NAME argumentlist parent LBRACE RBRACE { } | DEFINE classname argumentlist LBRACE RBRACE { @lexer.commentpop - newdefine classname(val[1]), :arguments => val[2], :line => val[0][:line] + result = Puppet::Parser::AST::Definition.new(classname(val[1]), + ast_context(true).merge(:arguments => val[2], :line => val[0][:line])) @lexer.indefine = false - result = nil } #hostclass: CLASS NAME argumentlist parent LBRACE statements RBRACE { @@ -681,24 +663,27 @@ hostclass: CLASS classname argumentlist classparent LBRACE statements RBRACE { @lexer.commentpop # Our class gets defined in the parent namespace, not our own. @lexer.namepop - newclass classname(val[1]), :arguments => val[2], :parent => val[3], :code => val[5], :line => val[0][:line] - result = nil + val[5].is_a_namespace = true + 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 - newclass classname(val[1]), :arguments => val[2], :parent => val[3], :line => val[0][:line] - result = nil + 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 - newnode val[1], :parent => val[2], :code => val[4], :line => val[0][:line] - result = nil + 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 - newnode val[1], :parent => val[2], :line => val[0][:line] - result = nil + result = Puppet::Parser::AST::Node.new(val[1], ast_context(true).merge(:parent => val[2], :line => val[0][:line])) } classref: CLASSREF { result = val[0][:value] } @@ -709,10 +694,11 @@ classname: NAME { result = val[0][:value] } # Multiple hostnames, as used for node names. These are all literal # strings, not AST objects. -hostnames: nodename +hostnames: nodename { + result = [result] +} | hostnames COMMA nodename { result = val[0] - result = [result] unless result.is_a?(Array) result << val[2] } diff --git a/lib/puppet/parser/parser.rb b/lib/puppet/parser/parser.rb index 5be9e5a3f..e4f5149b9 100644 --- a/lib/puppet/parser/parser.rb +++ b/lib/puppet/parser/parser.rb @@ -1,11 +1,10 @@ # # DO NOT MODIFY!!!! -# This file is automatically generated by racc 1.4.5 -# from racc grammer file "grammar.ra". +# This file is automatically generated by Racc 1.4.6 +# from Racc grammer file "". # -require 'racc/parser' - +require 'racc/parser.rb' require 'puppet' require 'puppet/util/loadedfile' @@ -13,19 +12,16 @@ require 'puppet/parser/lexer' require 'puppet/parser/ast' module Puppet - class ParseError < Puppet::Error; end - class ImportError < Racc::ParseError; end - class AlreadyImportedError < ImportError; end + class ParseError < Puppet::Error; end + class ImportError < Racc::ParseError; end + class AlreadyImportedError < ImportError; end end - module Puppet - module Parser - class Parser < Racc::Parser -module_eval <<'..end grammar.ra modeval..id7145220b1b', 'grammar.ra', 876 +module_eval(<<'...end grammar.ra/module_eval...', 'grammar.ra', 851) # It got too annoying having code in a file that needs to be compiled. require 'puppet/parser/parser_support' @@ -36,249 +32,8 @@ require 'puppet/parser/parser_support' # End: # $Id$ - -..end grammar.ra modeval..id7145220b1b - -##### racc 1.4.5 generates ### - -racc_reduce_table = [ - 0, 0, :racc_error, - 1, 70, :_reduce_1, - 1, 70, :_reduce_none, - 1, 71, :_reduce_none, - 2, 71, :_reduce_4, - 1, 73, :_reduce_none, - 1, 73, :_reduce_none, - 1, 73, :_reduce_none, - 1, 73, :_reduce_none, - 1, 73, :_reduce_none, - 1, 73, :_reduce_none, - 1, 73, :_reduce_none, - 1, 73, :_reduce_none, - 1, 73, :_reduce_none, - 1, 73, :_reduce_none, - 1, 73, :_reduce_none, - 1, 73, :_reduce_none, - 1, 73, :_reduce_none, - 1, 73, :_reduce_none, - 3, 87, :_reduce_19, - 3, 87, :_reduce_20, - 1, 88, :_reduce_none, - 1, 88, :_reduce_none, - 1, 88, :_reduce_none, - 1, 89, :_reduce_none, - 1, 89, :_reduce_none, - 1, 89, :_reduce_none, - 1, 89, :_reduce_none, - 4, 81, :_reduce_28, - 5, 81, :_reduce_29, - 3, 81, :_reduce_30, - 2, 81, :_reduce_31, - 1, 91, :_reduce_none, - 1, 91, :_reduce_none, - 3, 91, :_reduce_34, - 3, 91, :_reduce_35, - 1, 92, :_reduce_none, - 1, 92, :_reduce_none, - 1, 92, :_reduce_none, - 1, 92, :_reduce_none, - 1, 92, :_reduce_none, - 1, 92, :_reduce_none, - 1, 92, :_reduce_none, - 1, 92, :_reduce_none, - 1, 92, :_reduce_44, - 5, 74, :_reduce_45, - 5, 74, :_reduce_46, - 5, 74, :_reduce_47, - 5, 85, :_reduce_48, - 2, 75, :_reduce_49, - 1, 108, :_reduce_50, - 2, 108, :_reduce_51, - 6, 76, :_reduce_52, - 2, 76, :_reduce_53, - 3, 109, :_reduce_54, - 3, 109, :_reduce_55, - 1, 110, :_reduce_none, - 1, 110, :_reduce_none, - 3, 110, :_reduce_58, - 1, 111, :_reduce_none, - 3, 111, :_reduce_60, - 1, 112, :_reduce_61, - 1, 112, :_reduce_62, - 3, 113, :_reduce_63, - 3, 113, :_reduce_64, - 1, 114, :_reduce_none, - 1, 114, :_reduce_none, - 4, 116, :_reduce_67, - 1, 102, :_reduce_none, - 3, 102, :_reduce_69, - 0, 103, :_reduce_none, - 1, 103, :_reduce_none, - 1, 118, :_reduce_72, - 1, 93, :_reduce_73, - 1, 95, :_reduce_74, - 1, 117, :_reduce_none, - 1, 117, :_reduce_none, - 1, 117, :_reduce_none, - 1, 117, :_reduce_none, - 1, 117, :_reduce_none, - 1, 117, :_reduce_none, - 1, 117, :_reduce_none, - 3, 77, :_reduce_82, - 3, 77, :_reduce_83, - 3, 86, :_reduce_84, - 0, 104, :_reduce_85, - 1, 104, :_reduce_86, - 3, 104, :_reduce_87, - 3, 122, :_reduce_88, - 3, 124, :_reduce_89, - 1, 125, :_reduce_none, - 1, 125, :_reduce_none, - 0, 107, :_reduce_92, - 1, 107, :_reduce_93, - 3, 107, :_reduce_94, - 1, 126, :_reduce_none, - 3, 126, :_reduce_96, - 1, 115, :_reduce_none, - 1, 115, :_reduce_none, - 1, 115, :_reduce_none, - 1, 115, :_reduce_none, - 1, 115, :_reduce_none, - 1, 115, :_reduce_none, - 1, 123, :_reduce_none, - 1, 123, :_reduce_none, - 1, 123, :_reduce_none, - 1, 123, :_reduce_none, - 1, 123, :_reduce_none, - 1, 123, :_reduce_none, - 1, 123, :_reduce_none, - 1, 123, :_reduce_none, - 1, 123, :_reduce_none, - 1, 123, :_reduce_none, - 1, 123, :_reduce_none, - 1, 123, :_reduce_none, - 4, 97, :_reduce_115, - 3, 97, :_reduce_116, - 1, 99, :_reduce_117, - 2, 99, :_reduce_118, - 2, 129, :_reduce_119, - 1, 130, :_reduce_120, - 2, 130, :_reduce_121, - 1, 96, :_reduce_122, - 4, 90, :_reduce_123, - 4, 90, :_reduce_124, - 2, 79, :_reduce_125, - 5, 131, :_reduce_126, - 4, 131, :_reduce_127, - 0, 132, :_reduce_none, - 2, 132, :_reduce_129, - 4, 132, :_reduce_130, - 3, 132, :_reduce_131, - 1, 120, :_reduce_none, - 3, 120, :_reduce_133, - 3, 120, :_reduce_134, - 3, 120, :_reduce_135, - 3, 120, :_reduce_136, - 3, 120, :_reduce_137, - 3, 120, :_reduce_138, - 3, 120, :_reduce_139, - 3, 120, :_reduce_140, - 3, 120, :_reduce_141, - 2, 120, :_reduce_142, - 3, 120, :_reduce_143, - 3, 120, :_reduce_144, - 3, 120, :_reduce_145, - 3, 120, :_reduce_146, - 3, 120, :_reduce_147, - 3, 120, :_reduce_148, - 2, 120, :_reduce_149, - 3, 120, :_reduce_150, - 3, 120, :_reduce_151, - 3, 120, :_reduce_152, - 5, 78, :_reduce_153, - 1, 134, :_reduce_none, - 2, 134, :_reduce_155, - 5, 135, :_reduce_156, - 4, 135, :_reduce_157, - 1, 136, :_reduce_none, - 3, 136, :_reduce_159, - 3, 98, :_reduce_160, - 1, 138, :_reduce_none, - 4, 138, :_reduce_162, - 1, 140, :_reduce_none, - 3, 140, :_reduce_164, - 3, 139, :_reduce_165, - 1, 137, :_reduce_none, - 1, 137, :_reduce_none, - 1, 137, :_reduce_none, - 1, 137, :_reduce_none, - 1, 137, :_reduce_none, - 1, 137, :_reduce_none, - 1, 137, :_reduce_none, - 1, 137, :_reduce_173, - 1, 137, :_reduce_none, - 1, 141, :_reduce_175, - 1, 142, :_reduce_none, - 3, 142, :_reduce_177, - 2, 80, :_reduce_178, - 6, 82, :_reduce_179, - 5, 82, :_reduce_180, - 7, 83, :_reduce_181, - 6, 83, :_reduce_182, - 6, 84, :_reduce_183, - 5, 84, :_reduce_184, - 1, 106, :_reduce_185, - 1, 101, :_reduce_186, - 1, 101, :_reduce_187, - 1, 101, :_reduce_188, - 1, 145, :_reduce_none, - 3, 145, :_reduce_190, - 1, 147, :_reduce_191, - 1, 148, :_reduce_192, - 1, 148, :_reduce_193, - 1, 148, :_reduce_194, - 1, 148, :_reduce_none, - 0, 72, :_reduce_196, - 0, 149, :_reduce_197, - 1, 143, :_reduce_none, - 3, 143, :_reduce_199, - 3, 143, :_reduce_200, - 1, 150, :_reduce_none, - 3, 150, :_reduce_202, - 3, 151, :_reduce_203, - 1, 151, :_reduce_204, - 3, 151, :_reduce_205, - 1, 151, :_reduce_206, - 1, 146, :_reduce_none, - 2, 146, :_reduce_208, - 1, 144, :_reduce_none, - 2, 144, :_reduce_210, - 1, 152, :_reduce_none, - 1, 152, :_reduce_none, - 1, 94, :_reduce_213, - 3, 119, :_reduce_214, - 4, 119, :_reduce_215, - 2, 119, :_reduce_216, - 1, 127, :_reduce_none, - 1, 127, :_reduce_none, - 0, 105, :_reduce_none, - 1, 105, :_reduce_220, - 1, 133, :_reduce_221, - 3, 128, :_reduce_222, - 4, 128, :_reduce_223, - 2, 128, :_reduce_224, - 1, 153, :_reduce_none, - 3, 153, :_reduce_226, - 3, 154, :_reduce_227, - 1, 155, :_reduce_228, - 1, 155, :_reduce_229, - 4, 121, :_reduce_230, - 1, 100, :_reduce_none, - 4, 100, :_reduce_232 ] - -racc_reduce_n = 233 - -racc_shift_n = 384 +...end grammar.ra/module_eval... +##### State transition tables begin ### racc_action_table = [ 256, 257, 228, 82, 54, 72, 75, 181, 251, 48, @@ -920,1683 +675,2015 @@ racc_goto_default = [ nil, nil, nil, nil, nil, nil, nil, nil, nil, 57, nil, nil, nil, nil, nil, nil, 192 ] -racc_token_table = { - false => 0, - Object.new => 1, - :STRING => 2, - :DQPRE => 3, - :DQMID => 4, - :DQPOST => 5, - :LBRACK => 6, - :RBRACK => 7, - :LBRACE => 8, - :RBRACE => 9, - :SYMBOL => 10, - :FARROW => 11, - :COMMA => 12, - :TRUE => 13, - :FALSE => 14, - :EQUALS => 15, - :APPENDS => 16, - :LESSEQUAL => 17, - :NOTEQUAL => 18, - :DOT => 19, - :COLON => 20, - :LLCOLLECT => 21, - :RRCOLLECT => 22, - :QMARK => 23, - :LPAREN => 24, - :RPAREN => 25, - :ISEQUAL => 26, - :GREATEREQUAL => 27, - :GREATERTHAN => 28, - :LESSTHAN => 29, - :IF => 30, - :ELSE => 31, - :IMPORT => 32, - :DEFINE => 33, - :ELSIF => 34, - :VARIABLE => 35, - :CLASS => 36, - :INHERITS => 37, - :NODE => 38, - :BOOLEAN => 39, - :NAME => 40, - :SEMIC => 41, - :CASE => 42, - :DEFAULT => 43, - :AT => 44, - :LCOLLECT => 45, - :RCOLLECT => 46, - :CLASSNAME => 47, - :CLASSREF => 48, - :NOT => 49, - :OR => 50, - :AND => 51, - :UNDEF => 52, - :PARROW => 53, - :PLUS => 54, - :MINUS => 55, - :TIMES => 56, - :DIV => 57, - :LSHIFT => 58, - :RSHIFT => 59, - :UMINUS => 60, - :MATCH => 61, - :NOMATCH => 62, - :REGEX => 63, - :IN_EDGE => 64, - :OUT_EDGE => 65, - :IN_EDGE_SUB => 66, - :OUT_EDGE_SUB => 67, - :IN => 68 } +racc_reduce_table = [ + 0, 0, :racc_error, + 1, 70, :_reduce_1, + 1, 70, :_reduce_none, + 1, 71, :_reduce_3, + 2, 71, :_reduce_4, + 1, 73, :_reduce_none, + 1, 73, :_reduce_none, + 1, 73, :_reduce_none, + 1, 73, :_reduce_none, + 1, 73, :_reduce_none, + 1, 73, :_reduce_none, + 1, 73, :_reduce_none, + 1, 73, :_reduce_none, + 1, 73, :_reduce_none, + 1, 73, :_reduce_none, + 1, 73, :_reduce_none, + 1, 73, :_reduce_none, + 1, 73, :_reduce_none, + 1, 73, :_reduce_none, + 3, 87, :_reduce_19, + 3, 87, :_reduce_20, + 1, 88, :_reduce_none, + 1, 88, :_reduce_none, + 1, 88, :_reduce_none, + 1, 89, :_reduce_none, + 1, 89, :_reduce_none, + 1, 89, :_reduce_none, + 1, 89, :_reduce_none, + 4, 81, :_reduce_28, + 5, 81, :_reduce_29, + 3, 81, :_reduce_30, + 2, 81, :_reduce_31, + 1, 91, :_reduce_none, + 1, 91, :_reduce_none, + 3, 91, :_reduce_34, + 3, 91, :_reduce_35, + 1, 92, :_reduce_none, + 1, 92, :_reduce_none, + 1, 92, :_reduce_none, + 1, 92, :_reduce_none, + 1, 92, :_reduce_none, + 1, 92, :_reduce_none, + 1, 92, :_reduce_none, + 1, 92, :_reduce_none, + 1, 92, :_reduce_44, + 5, 74, :_reduce_45, + 5, 74, :_reduce_46, + 5, 74, :_reduce_47, + 5, 85, :_reduce_48, + 2, 75, :_reduce_49, + 1, 108, :_reduce_50, + 2, 108, :_reduce_51, + 6, 76, :_reduce_52, + 2, 76, :_reduce_53, + 3, 109, :_reduce_54, + 3, 109, :_reduce_55, + 1, 110, :_reduce_none, + 1, 110, :_reduce_none, + 3, 110, :_reduce_58, + 1, 111, :_reduce_none, + 3, 111, :_reduce_60, + 1, 112, :_reduce_61, + 1, 112, :_reduce_62, + 3, 113, :_reduce_63, + 3, 113, :_reduce_64, + 1, 114, :_reduce_none, + 1, 114, :_reduce_none, + 4, 116, :_reduce_67, + 1, 102, :_reduce_none, + 3, 102, :_reduce_69, + 0, 103, :_reduce_none, + 1, 103, :_reduce_none, + 1, 118, :_reduce_72, + 1, 93, :_reduce_73, + 1, 95, :_reduce_74, + 1, 117, :_reduce_none, + 1, 117, :_reduce_none, + 1, 117, :_reduce_none, + 1, 117, :_reduce_none, + 1, 117, :_reduce_none, + 1, 117, :_reduce_none, + 1, 117, :_reduce_none, + 3, 77, :_reduce_82, + 3, 77, :_reduce_83, + 3, 86, :_reduce_84, + 0, 104, :_reduce_85, + 1, 104, :_reduce_86, + 3, 104, :_reduce_87, + 3, 122, :_reduce_88, + 3, 124, :_reduce_89, + 1, 125, :_reduce_none, + 1, 125, :_reduce_none, + 0, 107, :_reduce_92, + 1, 107, :_reduce_93, + 3, 107, :_reduce_94, + 1, 126, :_reduce_none, + 3, 126, :_reduce_96, + 1, 115, :_reduce_none, + 1, 115, :_reduce_none, + 1, 115, :_reduce_none, + 1, 115, :_reduce_none, + 1, 115, :_reduce_none, + 1, 115, :_reduce_none, + 1, 123, :_reduce_none, + 1, 123, :_reduce_none, + 1, 123, :_reduce_none, + 1, 123, :_reduce_none, + 1, 123, :_reduce_none, + 1, 123, :_reduce_none, + 1, 123, :_reduce_none, + 1, 123, :_reduce_none, + 1, 123, :_reduce_none, + 1, 123, :_reduce_none, + 1, 123, :_reduce_none, + 1, 123, :_reduce_none, + 4, 97, :_reduce_115, + 3, 97, :_reduce_116, + 1, 99, :_reduce_117, + 2, 99, :_reduce_118, + 2, 129, :_reduce_119, + 1, 130, :_reduce_120, + 2, 130, :_reduce_121, + 1, 96, :_reduce_122, + 4, 90, :_reduce_123, + 4, 90, :_reduce_124, + 2, 79, :_reduce_125, + 5, 131, :_reduce_126, + 4, 131, :_reduce_127, + 0, 132, :_reduce_none, + 2, 132, :_reduce_129, + 4, 132, :_reduce_130, + 3, 132, :_reduce_131, + 1, 120, :_reduce_none, + 3, 120, :_reduce_133, + 3, 120, :_reduce_134, + 3, 120, :_reduce_135, + 3, 120, :_reduce_136, + 3, 120, :_reduce_137, + 3, 120, :_reduce_138, + 3, 120, :_reduce_139, + 3, 120, :_reduce_140, + 3, 120, :_reduce_141, + 2, 120, :_reduce_142, + 3, 120, :_reduce_143, + 3, 120, :_reduce_144, + 3, 120, :_reduce_145, + 3, 120, :_reduce_146, + 3, 120, :_reduce_147, + 3, 120, :_reduce_148, + 2, 120, :_reduce_149, + 3, 120, :_reduce_150, + 3, 120, :_reduce_151, + 3, 120, :_reduce_152, + 5, 78, :_reduce_153, + 1, 134, :_reduce_none, + 2, 134, :_reduce_155, + 5, 135, :_reduce_156, + 4, 135, :_reduce_157, + 1, 136, :_reduce_none, + 3, 136, :_reduce_159, + 3, 98, :_reduce_160, + 1, 138, :_reduce_none, + 4, 138, :_reduce_162, + 1, 140, :_reduce_none, + 3, 140, :_reduce_164, + 3, 139, :_reduce_165, + 1, 137, :_reduce_none, + 1, 137, :_reduce_none, + 1, 137, :_reduce_none, + 1, 137, :_reduce_none, + 1, 137, :_reduce_none, + 1, 137, :_reduce_none, + 1, 137, :_reduce_none, + 1, 137, :_reduce_173, + 1, 137, :_reduce_none, + 1, 141, :_reduce_175, + 1, 142, :_reduce_none, + 3, 142, :_reduce_177, + 2, 80, :_reduce_178, + 6, 82, :_reduce_179, + 5, 82, :_reduce_180, + 7, 83, :_reduce_181, + 6, 83, :_reduce_182, + 6, 84, :_reduce_183, + 5, 84, :_reduce_184, + 1, 106, :_reduce_185, + 1, 101, :_reduce_186, + 1, 101, :_reduce_187, + 1, 101, :_reduce_188, + 1, 145, :_reduce_189, + 3, 145, :_reduce_190, + 1, 147, :_reduce_191, + 1, 148, :_reduce_192, + 1, 148, :_reduce_193, + 1, 148, :_reduce_194, + 1, 148, :_reduce_none, + 0, 72, :_reduce_196, + 0, 149, :_reduce_197, + 1, 143, :_reduce_none, + 3, 143, :_reduce_199, + 3, 143, :_reduce_200, + 1, 150, :_reduce_none, + 3, 150, :_reduce_202, + 3, 151, :_reduce_203, + 1, 151, :_reduce_204, + 3, 151, :_reduce_205, + 1, 151, :_reduce_206, + 1, 146, :_reduce_none, + 2, 146, :_reduce_208, + 1, 144, :_reduce_none, + 2, 144, :_reduce_210, + 1, 152, :_reduce_none, + 1, 152, :_reduce_none, + 1, 94, :_reduce_213, + 3, 119, :_reduce_214, + 4, 119, :_reduce_215, + 2, 119, :_reduce_216, + 1, 127, :_reduce_none, + 1, 127, :_reduce_none, + 0, 105, :_reduce_none, + 1, 105, :_reduce_220, + 1, 133, :_reduce_221, + 3, 128, :_reduce_222, + 4, 128, :_reduce_223, + 2, 128, :_reduce_224, + 1, 153, :_reduce_none, + 3, 153, :_reduce_226, + 3, 154, :_reduce_227, + 1, 155, :_reduce_228, + 1, 155, :_reduce_229, + 4, 121, :_reduce_230, + 1, 100, :_reduce_none, + 4, 100, :_reduce_232 ] -racc_use_result_var = true +racc_reduce_n = 233 + +racc_shift_n = 384 + +racc_token_table = { + false => 0, + :error => 1, + :STRING => 2, + :DQPRE => 3, + :DQMID => 4, + :DQPOST => 5, + :LBRACK => 6, + :RBRACK => 7, + :LBRACE => 8, + :RBRACE => 9, + :SYMBOL => 10, + :FARROW => 11, + :COMMA => 12, + :TRUE => 13, + :FALSE => 14, + :EQUALS => 15, + :APPENDS => 16, + :LESSEQUAL => 17, + :NOTEQUAL => 18, + :DOT => 19, + :COLON => 20, + :LLCOLLECT => 21, + :RRCOLLECT => 22, + :QMARK => 23, + :LPAREN => 24, + :RPAREN => 25, + :ISEQUAL => 26, + :GREATEREQUAL => 27, + :GREATERTHAN => 28, + :LESSTHAN => 29, + :IF => 30, + :ELSE => 31, + :IMPORT => 32, + :DEFINE => 33, + :ELSIF => 34, + :VARIABLE => 35, + :CLASS => 36, + :INHERITS => 37, + :NODE => 38, + :BOOLEAN => 39, + :NAME => 40, + :SEMIC => 41, + :CASE => 42, + :DEFAULT => 43, + :AT => 44, + :LCOLLECT => 45, + :RCOLLECT => 46, + :CLASSNAME => 47, + :CLASSREF => 48, + :NOT => 49, + :OR => 50, + :AND => 51, + :UNDEF => 52, + :PARROW => 53, + :PLUS => 54, + :MINUS => 55, + :TIMES => 56, + :DIV => 57, + :LSHIFT => 58, + :RSHIFT => 59, + :UMINUS => 60, + :MATCH => 61, + :NOMATCH => 62, + :REGEX => 63, + :IN_EDGE => 64, + :OUT_EDGE => 65, + :IN_EDGE_SUB => 66, + :OUT_EDGE_SUB => 67, + :IN => 68 } racc_nt_base = 69 +racc_use_result_var = true + 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_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', -'STRING', -'DQPRE', -'DQMID', -'DQPOST', -'LBRACK', -'RBRACK', -'LBRACE', -'RBRACE', -'SYMBOL', -'FARROW', -'COMMA', -'TRUE', -'FALSE', -'EQUALS', -'APPENDS', -'LESSEQUAL', -'NOTEQUAL', -'DOT', -'COLON', -'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', -'UNDEF', -'PARROW', -'PLUS', -'MINUS', -'TIMES', -'DIV', -'LSHIFT', -'RSHIFT', -'UMINUS', -'MATCH', -'NOMATCH', -'REGEX', -'IN_EDGE', -'OUT_EDGE', -'IN_EDGE_SUB', -'OUT_EDGE_SUB', -'IN', -'$start', -'program', -'statements', -'nil', -'statement', -'resource', -'virtualresource', -'collection', -'assignment', -'casestatement', -'ifstatement_begin', -'import', -'fstatement', -'definition', -'hostclass', -'nodedef', -'resourceoverride', -'append', -'relationship', -'relationship_side', -'edge', -'resourceref', -'funcvalues', -'namestring', -'name', -'variable', -'type', -'boolean', -'funcrvalue', -'selector', -'quotedtext', -'hasharrayaccesses', -'classname', -'resourceinstances', -'endsemi', -'params', -'endcomma', -'classref', -'anyparams', -'at', -'collectrhand', -'collstatements', -'collstatement', -'colljoin', -'collexpr', -'colllval', -'simplervalue', -'resourceinst', -'resourcename', -'undef', -'array', -'expression', -'hasharrayaccess', -'param', -'rvalue', -'addparam', -'anyparam', -'rvalues', -'comma', -'hash', -'dqrval', -'dqtail', -'ifstatement', -'else', -'regex', -'caseopts', -'caseopt', -'casevalues', -'selectlhand', -'svalues', -'selectval', -'sintvalues', -'string', -'strings', -'argumentlist', -'classparent', -'hostnames', -'nodeparent', -'nodename', -'hostname', -'nothing', -'arguments', -'argument', -'classnameordefault', -'hashpairs', -'hashpair', -'key'] + "$end", + "error", + "STRING", + "DQPRE", + "DQMID", + "DQPOST", + "LBRACK", + "RBRACK", + "LBRACE", + "RBRACE", + "SYMBOL", + "FARROW", + "COMMA", + "TRUE", + "FALSE", + "EQUALS", + "APPENDS", + "LESSEQUAL", + "NOTEQUAL", + "DOT", + "COLON", + "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", + "UNDEF", + "PARROW", + "PLUS", + "MINUS", + "TIMES", + "DIV", + "LSHIFT", + "RSHIFT", + "UMINUS", + "MATCH", + "NOMATCH", + "REGEX", + "IN_EDGE", + "OUT_EDGE", + "IN_EDGE_SUB", + "OUT_EDGE_SUB", + "IN", + "$start", + "program", + "statements", + "nil", + "statement", + "resource", + "virtualresource", + "collection", + "assignment", + "casestatement", + "ifstatement_begin", + "import", + "fstatement", + "definition", + "hostclass", + "nodedef", + "resourceoverride", + "append", + "relationship", + "relationship_side", + "edge", + "resourceref", + "funcvalues", + "namestring", + "name", + "variable", + "type", + "boolean", + "funcrvalue", + "selector", + "quotedtext", + "hasharrayaccesses", + "classname", + "resourceinstances", + "endsemi", + "params", + "endcomma", + "classref", + "anyparams", + "at", + "collectrhand", + "collstatements", + "collstatement", + "colljoin", + "collexpr", + "colllval", + "simplervalue", + "resourceinst", + "resourcename", + "undef", + "array", + "expression", + "hasharrayaccess", + "param", + "rvalue", + "addparam", + "anyparam", + "rvalues", + "comma", + "hash", + "dqrval", + "dqtail", + "ifstatement", + "else", + "regex", + "caseopts", + "caseopt", + "casevalues", + "selectlhand", + "svalues", + "selectval", + "sintvalues", + "string", + "strings", + "argumentlist", + "classparent", + "hostnames", + "nodeparent", + "nodename", + "hostname", + "nothing", + "arguments", + "argument", + "classnameordefault", + "hashpairs", + "hashpair", + "key" ] Racc_debug_parser = false -##### racc system variables end ##### - - # reduce 0 omitted - -module_eval <<'.,.,', 'grammar.ra', 46 - 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 +##### State transition tables end ##### + +# reduce 0 omitted + +module_eval(<<'.,.,', 'grammar.ra', 31) + def _reduce_1(val, _values, result) + val[0].is_a_namespace = true + result = val[0] + + result end .,., - # reduce 2 omitted +# reduce 2 omitted - # reduce 3 omitted +module_eval(<<'.,.,', 'grammar.ra', 37) + def _reduce_3(val, _values, result) + result = ast AST::ASTArray, :children => [val[0]] + + result + end +.,., -module_eval <<'.,.,', 'grammar.ra', 62 - 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 +module_eval(<<'.,.,', 'grammar.ra', 40) + def _reduce_4(val, _values, result) + val[0].push(val[1]) + result = val[0] + + result end .,., - # reduce 5 omitted +# reduce 5 omitted - # reduce 6 omitted +# reduce 6 omitted - # reduce 7 omitted +# reduce 7 omitted - # reduce 8 omitted +# reduce 8 omitted - # reduce 9 omitted +# reduce 9 omitted - # reduce 10 omitted +# reduce 10 omitted - # reduce 11 omitted +# reduce 11 omitted - # reduce 12 omitted +# reduce 12 omitted - # reduce 13 omitted +# reduce 13 omitted - # reduce 14 omitted +# reduce 14 omitted - # reduce 15 omitted +# reduce 15 omitted - # reduce 16 omitted +# reduce 16 omitted - # reduce 17 omitted +# reduce 17 omitted - # reduce 18 omitted +# reduce 18 omitted -module_eval <<'.,.,', 'grammar.ra', 82 - def _reduce_19( val, _values, result ) - result = AST::Relationship.new(val[0], val[2], val[1][:value], ast_context) - result +module_eval(<<'.,.,', 'grammar.ra', 61) + def _reduce_19(val, _values, result) + result = AST::Relationship.new(val[0], val[2], val[1][:value], ast_context) + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 85 - def _reduce_20( val, _values, result ) - result = AST::Relationship.new(val[0], val[2], val[1][:value], ast_context) - result +module_eval(<<'.,.,', 'grammar.ra', 64) + def _reduce_20(val, _values, result) + result = AST::Relationship.new(val[0], val[2], val[1][:value], ast_context) + + result end .,., - # reduce 21 omitted +# reduce 21 omitted - # reduce 22 omitted +# reduce 22 omitted - # reduce 23 omitted +# reduce 23 omitted - # reduce 24 omitted +# reduce 24 omitted - # reduce 25 omitted +# reduce 25 omitted - # reduce 26 omitted +# reduce 26 omitted - # reduce 27 omitted +# reduce 27 omitted -module_eval <<'.,.,', 'grammar.ra', 98 - def _reduce_28( val, _values, result ) - args = aryfy(val[2]) - result = ast AST::Function, - :name => val[0][:value], - :line => val[0][:line], - :arguments => args, - :ftype => :statement - result +module_eval(<<'.,.,', 'grammar.ra', 72) + def _reduce_28(val, _values, result) + args = aryfy(val[2]) + result = ast AST::Function, + :name => val[0][:value], + :line => val[0][:line], + :arguments => args, + :ftype => :statement + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 106 - def _reduce_29( val, _values, result ) - args = aryfy(val[2]) - result = ast AST::Function, - :name => val[0][:value], - :line => val[0][:line], - :arguments => args, - :ftype => :statement - result +module_eval(<<'.,.,', 'grammar.ra', 80) + def _reduce_29(val, _values, result) + args = aryfy(val[2]) + result = ast AST::Function, + :name => val[0][:value], + :line => val[0][:line], + :arguments => args, + :ftype => :statement + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 112 - def _reduce_30( val, _values, result ) - result = ast AST::Function, - :name => val[0][:value], - :line => val[0][:line], - :arguments => AST::ASTArray.new({}), - :ftype => :statement - result +module_eval(<<'.,.,', 'grammar.ra', 87) + def _reduce_30(val, _values, result) + result = ast AST::Function, + :name => val[0][:value], + :line => val[0][:line], + :arguments => AST::ASTArray.new({}), + :ftype => :statement + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 120 - def _reduce_31( val, _values, result ) - args = aryfy(val[1]) +module_eval(<<'.,.,', 'grammar.ra', 94) + def _reduce_31(val, _values, result) + args = aryfy(val[1]) result = ast AST::Function, - :name => val[0][:value], - :line => val[0][:line], - :arguments => args, - :ftype => :statement - result + :name => val[0][:value], + :line => val[0][:line], + :arguments => args, + :ftype => :statement + + result end .,., - # reduce 32 omitted +# reduce 32 omitted - # reduce 33 omitted +# reduce 33 omitted -module_eval <<'.,.,', 'grammar.ra', 128 - def _reduce_34( val, _values, result ) - result = aryfy(val[0], val[2]) +module_eval(<<'.,.,', 'grammar.ra', 105) + def _reduce_34(val, _values, result) + result = aryfy(val[0], val[2]) result.line = @lexer.line result.file = @lexer.file - result + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 137 - def _reduce_35( val, _values, result ) - unless val[0].is_a?(AST::ASTArray) - val[0] = aryfy(val[0]) - end +module_eval(<<'.,.,', 'grammar.ra', 110) + def _reduce_35(val, _values, result) + unless val[0].is_a?(AST::ASTArray) + val[0] = aryfy(val[0]) + end - val[0].push(val[2]) + val[0].push(val[2]) - result = val[0] - result + result = val[0] + + result end .,., - # reduce 36 omitted +# reduce 36 omitted - # reduce 37 omitted +# reduce 37 omitted - # reduce 38 omitted +# reduce 38 omitted - # reduce 39 omitted +# reduce 39 omitted - # reduce 40 omitted +# reduce 40 omitted - # reduce 41 omitted +# reduce 41 omitted - # reduce 42 omitted +# reduce 42 omitted - # reduce 43 omitted +# reduce 43 omitted -module_eval <<'.,.,', 'grammar.ra', 151 - def _reduce_44( val, _values, result ) - result = ast AST::Name, :value => val[0][:value] - result +module_eval(<<'.,.,', 'grammar.ra', 130) + def _reduce_44(val, _values, result) + result = ast AST::Name, :value => val[0][:value] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 173 - def _reduce_45( val, _values, result ) - @lexer.commentpop - array = val[2] - if array.instance_of?(AST::ResourceInstance) - array = [array] - end - result = ast AST::ASTArray +module_eval(<<'.,.,', 'grammar.ra', 134) + def _reduce_45(val, _values, result) + @lexer.commentpop + array = val[2] + array = [array] if array.instance_of?(AST::ResourceInstance) + result = ast AST::ASTArray + + # this iterates across each specified resourceinstance + array.each { |instance| + raise Puppet::Dev, "Got something that isn't an instance" unless instance.instance_of?(AST::ResourceInstance) + # now, i need to somehow differentiate between those things with + # arrays in their names, and normal things + + result.push ast( + AST::Resource, + :type => val[0], + :title => instance[0], + + :parameters => instance[1]) + } - # this iterates across each specified resourceinstance - array.each { |instance| - unless instance.instance_of?(AST::ResourceInstance) - 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::Resource, - :type => val[0], - :title => instance[0], - :parameters => instance[1]) - } - result + result end .,., -module_eval <<'.,.,', 'grammar.ra', 176 - def _reduce_46( val, _values, result ) - # This is a deprecated syntax. - error "All resource specifications require names" - result +module_eval(<<'.,.,', 'grammar.ra', 153) + def _reduce_46(val, _values, result) + # This is a deprecated syntax. + error "All resource specifications require names" + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 180 - def _reduce_47( val, _values, result ) - # a defaults setting for a type - @lexer.commentpop - result = ast(AST::ResourceDefaults, :type => val[0], :parameters => val[2]) - result +module_eval(<<'.,.,', 'grammar.ra', 156) + def _reduce_47(val, _values, result) + # a defaults setting for a type + @lexer.commentpop + result = ast(AST::ResourceDefaults, :type => val[0], :parameters => val[2]) + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 186 - def _reduce_48( val, _values, result ) - @lexer.commentpop - result = ast AST::ResourceOverride, :object => val[0], :parameters => val[2] - result +module_eval(<<'.,.,', 'grammar.ra', 163) + def _reduce_48(val, _values, result) + @lexer.commentpop + result = ast AST::ResourceOverride, :object => val[0], :parameters => val[2] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 213 - def _reduce_49( val, _values, result ) - type = val[0] +module_eval(<<'.,.,', 'grammar.ra', 170) + def _reduce_49(val, _values, result) + type = val[0] - if (type == :exported and ! Puppet[:storeconfigs]) and ! Puppet[:parseonly] - Puppet.warning addcontext("You cannot collect without storeconfigs being set") - end + if (type == :exported and ! Puppet[:storeconfigs]) and ! Puppet[:parseonly] + Puppet.warning addcontext("You cannot collect without storeconfigs being set") + end - if val[1].is_a? AST::ResourceDefaults - error "Defaults are not virtualizable" - end + error "Defaults are not virtualizable" if val[1].is_a? AST::ResourceDefaults - method = type.to_s + "=" + 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) + # 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 + result = val[1] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 214 - def _reduce_50( val, _values, result ) - result = :virtual - result +module_eval(<<'.,.,', 'grammar.ra', 192) + def _reduce_50(val, _values, result) + result = :virtual + result end .,., -module_eval <<'.,.,', 'grammar.ra', 215 - def _reduce_51( val, _values, result ) - result = :exported - result +module_eval(<<'.,.,', 'grammar.ra', 193) + def _reduce_51(val, _values, result) + result = :exported + result end .,., -module_eval <<'.,.,', 'grammar.ra', 240 - def _reduce_52( val, _values, result ) - @lexer.commentpop - 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] and ! Puppet[:parseonly] - 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 - result +module_eval(<<'.,.,', 'grammar.ra', 198) + def _reduce_52(val, _values, result) + @lexer.commentpop + Puppet.warning addcontext("Collection names must now be capitalized") if val[0] =~ /^[a-z]/ + 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] and ! Puppet[:parseonly] + 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 + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 259 - def _reduce_53( 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] and ! Puppet[:parseonly] - Puppet.warning addcontext("You cannot collect exported resources without storeconfigs being set; the collection will be ignored") - end - result = ast AST::Collection, args - result +module_eval(<<'.,.,', 'grammar.ra', 217) + def _reduce_53(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] and ! Puppet[:parseonly] + Puppet.warning addcontext("You cannot collect exported resources without storeconfigs being set; the collection will be ignored") + end + result = ast AST::Collection, args + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 269 - def _reduce_54( val, _values, result ) - if val[1] - result = val[1] - result.form = :virtual - else - result = :virtual - end - result +module_eval(<<'.,.,', 'grammar.ra', 238) + def _reduce_54(val, _values, result) + if val[1] + result = val[1] + result.form = :virtual + else + result = :virtual + end + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 277 - def _reduce_55( val, _values, result ) - if val[1] - result = val[1] - result.form = :exported - else - result = :exported - end - result +module_eval(<<'.,.,', 'grammar.ra', 246) + def _reduce_55(val, _values, result) + if val[1] + result = val[1] + result.form = :exported + else + result = :exported + end + + result end .,., - # reduce 56 omitted +# reduce 56 omitted + +# reduce 57 omitted - # reduce 57 omitted +module_eval(<<'.,.,', 'grammar.ra', 259) + def _reduce_58(val, _values, result) + result = ast AST::CollExpr, :test1 => val[0], :oper => val[1], :test2 => val[2] -module_eval <<'.,.,', 'grammar.ra', 285 - def _reduce_58( val, _values, result ) - result = ast AST::CollExpr, :test1 => val[0], :oper => val[1], :test2 => val[2] - result + result end .,., - # reduce 59 omitted +# reduce 59 omitted -module_eval <<'.,.,', 'grammar.ra', 291 - def _reduce_60( val, _values, result ) - result = val[1] +module_eval(<<'.,.,', 'grammar.ra', 264) + def _reduce_60(val, _values, result) + result = val[1] result.parens = true - result + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 292 - def _reduce_61( val, _values, result ) - result=val[0][:value] - result +module_eval(<<'.,.,', 'grammar.ra', 268) + def _reduce_61(val, _values, result) + result=val[0][:value] + result end .,., -module_eval <<'.,.,', 'grammar.ra', 293 - def _reduce_62( val, _values, result ) - result=val[0][:value] - result +module_eval(<<'.,.,', 'grammar.ra', 269) + def _reduce_62(val, _values, result) + result=val[0][:value] + result end .,., -module_eval <<'.,.,', 'grammar.ra', 300 - def _reduce_63( val, _values, result ) - result = ast AST::CollExpr, :test1 => val[0], :oper => val[1][:value], :test2 => val[2] - #result = ast AST::CollExpr - #result.push *val - result +module_eval(<<'.,.,', 'grammar.ra', 272) + def _reduce_63(val, _values, result) + result = ast AST::CollExpr, :test1 => val[0], :oper => val[1][:value], :test2 => val[2] + #result = ast AST::CollExpr + #result.push *val + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 305 - def _reduce_64( val, _values, result ) - result = ast AST::CollExpr, :test1 => val[0], :oper => val[1][:value], :test2 => val[2] +module_eval(<<'.,.,', 'grammar.ra', 277) + def _reduce_64(val, _values, result) + result = ast AST::CollExpr, :test1 => val[0], :oper => val[1][:value], :test2 => val[2] #result = ast AST::CollExpr #result.push *val - result + + result end .,., - # reduce 65 omitted +# reduce 65 omitted - # reduce 66 omitted +# reduce 66 omitted -module_eval <<'.,.,', 'grammar.ra', 312 - def _reduce_67( val, _values, result ) - result = ast AST::ResourceInstance, :children => [val[0],val[2]] - result +module_eval(<<'.,.,', 'grammar.ra', 286) + def _reduce_67(val, _values, result) + result = ast AST::ResourceInstance, :children => [val[0],val[2]] + + result end .,., - # reduce 68 omitted +# reduce 68 omitted -module_eval <<'.,.,', 'grammar.ra', 322 - def _reduce_69( val, _values, result ) - if val[0].instance_of?(AST::ResourceInstance) - result = ast AST::ASTArray, :children => [val[0],val[2]] - else - val[0].push val[2] - result = val[0] - end - result +module_eval(<<'.,.,', 'grammar.ra', 291) + def _reduce_69(val, _values, result) + if val[0].instance_of?(AST::ResourceInstance) + result = ast AST::ASTArray, :children => [val[0],val[2]] + else + val[0].push val[2] + result = val[0] + end + + result end .,., - # reduce 70 omitted +# reduce 70 omitted - # reduce 71 omitted +# reduce 71 omitted -module_eval <<'.,.,', 'grammar.ra', 329 - def _reduce_72( val, _values, result ) - result = ast AST::Undef, :value => :undef - result +module_eval(<<'.,.,', 'grammar.ra', 303) + def _reduce_72(val, _values, result) + result = ast AST::Undef, :value => :undef + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 333 - def _reduce_73( val, _values, result ) - result = ast AST::Name, :value => val[0][:value], :line => val[0][:line] - result +module_eval(<<'.,.,', 'grammar.ra', 307) + def _reduce_73(val, _values, result) + result = ast AST::Name, :value => val[0][:value], :line => val[0][:line] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 337 - def _reduce_74( val, _values, result ) - result = ast AST::Type, :value => val[0][:value], :line => val[0][:line] - result +module_eval(<<'.,.,', 'grammar.ra', 311) + def _reduce_74(val, _values, result) + result = ast AST::Type, :value => val[0][:value], :line => val[0][:line] + + result end .,., - # reduce 75 omitted +# reduce 75 omitted - # reduce 76 omitted +# reduce 76 omitted - # reduce 77 omitted +# reduce 77 omitted - # reduce 78 omitted +# reduce 78 omitted - # reduce 79 omitted +# reduce 79 omitted - # reduce 80 omitted +# reduce 80 omitted - # reduce 81 omitted +# reduce 81 omitted -module_eval <<'.,.,', 'grammar.ra', 354 - def _reduce_82( val, _values, result ) - if val[0][:value] =~ /::/ - raise Puppet::ParseError, "Cannot assign to variables in other namespaces" - end - # 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] - result +module_eval(<<'.,.,', 'grammar.ra', 323) + def _reduce_82(val, _values, result) + 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] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 357 - def _reduce_83( val, _values, result ) - result = ast AST::VarDef, :name => val[0], :value => val[2] - result +module_eval(<<'.,.,', 'grammar.ra', 329) + def _reduce_83(val, _values, result) + result = ast AST::VarDef, :name => val[0], :value => val[2] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 362 - def _reduce_84( val, _values, result ) - 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] - result +module_eval(<<'.,.,', 'grammar.ra', 333) + def _reduce_84(val, _values, result) + 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] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 367 - def _reduce_85( val, _values, result ) - result = ast AST::ASTArray - result +module_eval(<<'.,.,', 'grammar.ra', 339) + def _reduce_85(val, _values, result) + result = ast AST::ASTArray + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 367 - def _reduce_86( val, _values, result ) - result = val[0] - result +module_eval(<<'.,.,', 'grammar.ra', 341) + def _reduce_86(val, _values, result) + result = val[0] + result end .,., -module_eval <<'.,.,', 'grammar.ra', 376 - def _reduce_87( 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 +module_eval(<<'.,.,', 'grammar.ra', 343) + def _reduce_87(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', 380 - def _reduce_88( val, _values, result ) - result = ast AST::ResourceParam, :param => val[0][:value], :line => val[0][:line], :value => val[2] - result +module_eval(<<'.,.,', 'grammar.ra', 352) + def _reduce_88(val, _values, result) + result = ast AST::ResourceParam, :param => val[0][:value], :line => val[0][:line], :value => val[2] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 385 - def _reduce_89( val, _values, result ) - result = ast AST::ResourceParam, :param => val[0][:value], :line => val[0][:line], :value => val[2], - :add => true - result +module_eval(<<'.,.,', 'grammar.ra', 356) + def _reduce_89(val, _values, result) + result = ast AST::ResourceParam, :param => val[0][:value], :line => val[0][:line], :value => val[2], + :add => true + + result end .,., - # reduce 90 omitted +# reduce 90 omitted - # reduce 91 omitted +# reduce 91 omitted -module_eval <<'.,.,', 'grammar.ra', 393 - def _reduce_92( val, _values, result ) - result = ast AST::ASTArray - result +module_eval(<<'.,.,', 'grammar.ra', 365) + def _reduce_92(val, _values, result) + result = ast AST::ASTArray + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 393 - def _reduce_93( val, _values, result ) - result = val[0] - result +module_eval(<<'.,.,', 'grammar.ra', 367) + def _reduce_93(val, _values, result) + result = val[0] + result end .,., -module_eval <<'.,.,', 'grammar.ra', 402 - def _reduce_94( 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 +module_eval(<<'.,.,', 'grammar.ra', 369) + def _reduce_94(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 .,., - # reduce 95 omitted +# reduce 95 omitted -module_eval <<'.,.,', 'grammar.ra', 411 - def _reduce_96( 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 +module_eval(<<'.,.,', 'grammar.ra', 379) + def _reduce_96(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 97 omitted +# reduce 97 omitted - # reduce 98 omitted +# reduce 98 omitted - # reduce 99 omitted +# reduce 99 omitted - # reduce 100 omitted +# reduce 100 omitted - # reduce 101 omitted +# reduce 101 omitted - # reduce 102 omitted +# reduce 102 omitted - # reduce 103 omitted +# reduce 103 omitted - # reduce 104 omitted +# reduce 104 omitted - # reduce 105 omitted +# reduce 105 omitted - # reduce 106 omitted +# reduce 106 omitted - # reduce 107 omitted +# reduce 107 omitted - # reduce 108 omitted +# reduce 108 omitted - # reduce 109 omitted +# reduce 109 omitted - # reduce 110 omitted +# reduce 110 omitted - # reduce 111 omitted +# reduce 111 omitted - # reduce 112 omitted +# reduce 112 omitted - # reduce 113 omitted +# reduce 113 omitted - # reduce 114 omitted +# reduce 114 omitted -module_eval <<'.,.,', 'grammar.ra', 440 - def _reduce_115( val, _values, result ) - args = aryfy(val[2]) - result = ast AST::Function, - :name => val[0][:value], :line => val[0][:line], - :arguments => args, - :ftype => :rvalue - result +module_eval(<<'.,.,', 'grammar.ra', 408) + def _reduce_115(val, _values, result) + args = aryfy(val[2]) + result = ast AST::Function, + :name => val[0][:value], :line => val[0][:line], + :arguments => args, + :ftype => :rvalue + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 445 - def _reduce_116( val, _values, result ) - result = ast AST::Function, - :name => val[0][:value], :line => val[0][:line], - :arguments => AST::ASTArray.new({}), - :ftype => :rvalue - result +module_eval(<<'.,.,', 'grammar.ra', 414) + def _reduce_116(val, _values, result) + result = ast AST::Function, + :name => val[0][:value], :line => val[0][:line], + :arguments => AST::ASTArray.new({}), + :ftype => :rvalue + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 446 - def _reduce_117( val, _values, result ) - result = ast AST::String, :value => val[0][:value], :line => val[0][:line] - result +module_eval(<<'.,.,', 'grammar.ra', 420) + def _reduce_117(val, _values, result) + result = ast AST::String, :value => val[0][:value], :line => val[0][:line] + result end .,., -module_eval <<'.,.,', 'grammar.ra', 447 - def _reduce_118( val, _values, result ) - result = ast AST::Concat, :value => [ast(AST::String,val[0])]+val[1], :line => val[0][:line] - result +module_eval(<<'.,.,', 'grammar.ra', 421) + def _reduce_118(val, _values, result) + result = ast AST::Concat, :value => [ast(AST::String,val[0])]+val[1], :line => val[0][:line] + result end .,., -module_eval <<'.,.,', 'grammar.ra', 449 - def _reduce_119( val, _values, result ) - result = [val[0]] + val[1] - result +module_eval(<<'.,.,', 'grammar.ra', 423) + def _reduce_119(val, _values, result) + result = [val[0]] + val[1] + result end .,., -module_eval <<'.,.,', 'grammar.ra', 451 - def _reduce_120( val, _values, result ) - result = [ast(AST::String,val[0])] - result +module_eval(<<'.,.,', 'grammar.ra', 425) + def _reduce_120(val, _values, result) + result = [ast(AST::String,val[0])] + result end .,., -module_eval <<'.,.,', 'grammar.ra', 452 - def _reduce_121( val, _values, result ) - result = [ast(AST::String,val[0])] + val[1] - result +module_eval(<<'.,.,', 'grammar.ra', 426) + def _reduce_121(val, _values, result) + result = [ast(AST::String,val[0])] + val[1] + result end .,., -module_eval <<'.,.,', 'grammar.ra', 457 - def _reduce_122( val, _values, result ) - result = ast AST::Boolean, :value => val[0][:value], :line => val[0][:line] - result +module_eval(<<'.,.,', 'grammar.ra', 429) + def _reduce_122(val, _values, result) + result = ast AST::Boolean, :value => val[0][:value], :line => val[0][:line] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 462 - def _reduce_123( val, _values, result ) - 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] - result +module_eval(<<'.,.,', 'grammar.ra', 433) + def _reduce_123(val, _values, result) + 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] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 464 - def _reduce_124( val, _values, result ) - result = ast AST::ResourceReference, :type => val[0], :title => val[2] - result +module_eval(<<'.,.,', 'grammar.ra', 436) + def _reduce_124(val, _values, result) + result = ast AST::ResourceReference, :type => val[0], :title => val[2] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 468 - def _reduce_125( val, _values, result ) - result = val[1] - result +module_eval(<<'.,.,', 'grammar.ra', 440) + def _reduce_125(val, _values, result) + result = val[1] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 482 - def _reduce_126( val, _values, result ) - @lexer.commentpop - args = { - :test => val[0], - :statements => val[2] - } +module_eval(<<'.,.,', 'grammar.ra', 444) + def _reduce_126(val, _values, result) + @lexer.commentpop + args = { + :test => val[0], + :statements => val[2] + } - if val[4] - args[:else] = val[4] - end + args[:else] = val[4] if val[4] - result = ast AST::IfStatement, args - result + result = ast AST::IfStatement, args + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 495 - def _reduce_127( val, _values, result ) - @lexer.commentpop +module_eval(<<'.,.,', 'grammar.ra', 455) + def _reduce_127(val, _values, result) + @lexer.commentpop args = { - :test => val[0], - :statements => ast(AST::Nop) - } + :test => val[0], + :statements => ast(AST::Nop) + } - if val[3] - args[:else] = val[3] - end + args[:else] = val[3] if val[3] - result = ast AST::IfStatement, args - result + result = ast AST::IfStatement, args + + result end .,., - # reduce 128 omitted +# reduce 128 omitted + +module_eval(<<'.,.,', 'grammar.ra', 468) + def _reduce_129(val, _values, result) + result = ast AST::Else, :statements => val[1] -module_eval <<'.,.,', 'grammar.ra', 501 - def _reduce_129( val, _values, result ) - #@lexer.commentpop - result = ast AST::Else, :statements => val[1] - result + result end .,., -module_eval <<'.,.,', 'grammar.ra', 505 - def _reduce_130( val, _values, result ) - @lexer.commentpop +module_eval(<<'.,.,', 'grammar.ra', 471) + def _reduce_130(val, _values, result) + @lexer.commentpop result = ast AST::Else, :statements => val[2] - result + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 509 - def _reduce_131( val, _values, result ) - @lexer.commentpop +module_eval(<<'.,.,', 'grammar.ra', 475) + def _reduce_131(val, _values, result) + @lexer.commentpop result = ast AST::Else, :statements => ast(AST::Nop) - result + + result end .,., - # reduce 132 omitted +# reduce 132 omitted -module_eval <<'.,.,', 'grammar.ra', 526 - def _reduce_133( val, _values, result ) - result = ast AST::InOperator, :lval => val[0], :rval => val[2] - result +module_eval(<<'.,.,', 'grammar.ra', 493) + def _reduce_133(val, _values, result) + result = ast AST::InOperator, :lval => val[0], :rval => val[2] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 529 - def _reduce_134( val, _values, result ) - result = ast AST::MatchOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] - result +module_eval(<<'.,.,', 'grammar.ra', 496) + def _reduce_134(val, _values, result) + result = ast AST::MatchOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 532 - def _reduce_135( val, _values, result ) - result = ast AST::MatchOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] - result +module_eval(<<'.,.,', 'grammar.ra', 499) + def _reduce_135(val, _values, result) + result = ast AST::MatchOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 535 - def _reduce_136( val, _values, result ) - result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] - result +module_eval(<<'.,.,', 'grammar.ra', 502) + def _reduce_136(val, _values, result) + result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 538 - def _reduce_137( val, _values, result ) - result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] - result +module_eval(<<'.,.,', 'grammar.ra', 505) + def _reduce_137(val, _values, result) + result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 541 - def _reduce_138( val, _values, result ) - result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] - result +module_eval(<<'.,.,', 'grammar.ra', 508) + def _reduce_138(val, _values, result) + result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 544 - def _reduce_139( val, _values, result ) - result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] - result +module_eval(<<'.,.,', 'grammar.ra', 511) + def _reduce_139(val, _values, result) + result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 547 - def _reduce_140( val, _values, result ) - result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] - result +module_eval(<<'.,.,', 'grammar.ra', 514) + def _reduce_140(val, _values, result) + result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 550 - def _reduce_141( val, _values, result ) - result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] - result +module_eval(<<'.,.,', 'grammar.ra', 517) + def _reduce_141(val, _values, result) + result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 553 - def _reduce_142( val, _values, result ) - result = ast AST::Minus, :value => val[1] - result +module_eval(<<'.,.,', 'grammar.ra', 520) + def _reduce_142(val, _values, result) + result = ast AST::Minus, :value => val[1] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 556 - def _reduce_143( val, _values, result ) - result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] - result +module_eval(<<'.,.,', 'grammar.ra', 523) + def _reduce_143(val, _values, result) + result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 559 - def _reduce_144( val, _values, result ) - result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] - result +module_eval(<<'.,.,', 'grammar.ra', 526) + def _reduce_144(val, _values, result) + result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 562 - def _reduce_145( val, _values, result ) - result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] - result +module_eval(<<'.,.,', 'grammar.ra', 529) + def _reduce_145(val, _values, result) + result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 565 - def _reduce_146( val, _values, result ) - result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] - result +module_eval(<<'.,.,', 'grammar.ra', 532) + def _reduce_146(val, _values, result) + result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 568 - def _reduce_147( val, _values, result ) - result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] - result +module_eval(<<'.,.,', 'grammar.ra', 535) + def _reduce_147(val, _values, result) + result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 571 - def _reduce_148( val, _values, result ) - result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] - result +module_eval(<<'.,.,', 'grammar.ra', 538) + def _reduce_148(val, _values, result) + result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 574 - def _reduce_149( val, _values, result ) - result = ast AST::Not, :value => val[1] - result +module_eval(<<'.,.,', 'grammar.ra', 541) + def _reduce_149(val, _values, result) + result = ast AST::Not, :value => val[1] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 577 - def _reduce_150( val, _values, result ) - result = ast AST::BooleanOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] - result +module_eval(<<'.,.,', 'grammar.ra', 544) + def _reduce_150(val, _values, result) + result = ast AST::BooleanOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 580 - def _reduce_151( val, _values, result ) - result = ast AST::BooleanOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] - result +module_eval(<<'.,.,', 'grammar.ra', 547) + def _reduce_151(val, _values, result) + result = ast AST::BooleanOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 583 - def _reduce_152( val, _values, result ) - result = val[1] - result +module_eval(<<'.,.,', 'grammar.ra', 550) + def _reduce_152(val, _values, result) + result = val[1] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 592 - def _reduce_153( val, _values, result ) - @lexer.commentpop - 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 +module_eval(<<'.,.,', 'grammar.ra', 554) + def _reduce_153(val, _values, result) + @lexer.commentpop + options = val[3] + options = ast AST::ASTArray, :children => [val[3]] unless options.instance_of?(AST::ASTArray) + result = ast AST::CaseStatement, :test => val[1], :options => options + + result end .,., - # reduce 154 omitted +# reduce 154 omitted -module_eval <<'.,.,', 'grammar.ra', 602 - def _reduce_155( 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 +module_eval(<<'.,.,', 'grammar.ra', 562) + def _reduce_155(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', 607 - def _reduce_156( val, _values, result ) - @lexer.commentpop - result = ast AST::CaseOpt, :value => val[0], :statements => val[3] - result +module_eval(<<'.,.,', 'grammar.ra', 571) + def _reduce_156(val, _values, result) + @lexer.commentpop + result = ast AST::CaseOpt, :value => val[0], :statements => val[3] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 613 - def _reduce_157( val, _values, result ) - @lexer.commentpop - result = ast(AST::CaseOpt, - :value => val[0], - :statements => ast(AST::ASTArray) - ) - result +module_eval(<<'.,.,', 'grammar.ra', 574) + def _reduce_157(val, _values, result) + @lexer.commentpop + + result = ast( + AST::CaseOpt, + :value => val[0], + + :statements => ast(AST::ASTArray) + ) + + result end .,., - # reduce 158 omitted +# reduce 158 omitted -module_eval <<'.,.,', 'grammar.ra', 623 - def _reduce_159( 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 +module_eval(<<'.,.,', 'grammar.ra', 586) + def _reduce_159(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', 627 - def _reduce_160( val, _values, result ) - result = ast AST::Selector, :param => val[0], :values => val[2] - result +module_eval(<<'.,.,', 'grammar.ra', 595) + def _reduce_160(val, _values, result) + result = ast AST::Selector, :param => val[0], :values => val[2] + + result end .,., - # reduce 161 omitted +# reduce 161 omitted -module_eval <<'.,.,', 'grammar.ra', 633 - def _reduce_162( val, _values, result ) - @lexer.commentpop +module_eval(<<'.,.,', 'grammar.ra', 600) + def _reduce_162(val, _values, result) + @lexer.commentpop result = val[1] - result + + result end .,., - # reduce 163 omitted +# reduce 163 omitted -module_eval <<'.,.,', 'grammar.ra', 643 - def _reduce_164( 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 +module_eval(<<'.,.,', 'grammar.ra', 606) + def _reduce_164(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', 647 - def _reduce_165( val, _values, result ) - result = ast AST::ResourceParam, :param => val[0], :value => val[2] - result +module_eval(<<'.,.,', 'grammar.ra', 615) + def _reduce_165(val, _values, result) + result = ast AST::ResourceParam, :param => val[0], :value => val[2] + + result end .,., - # reduce 166 omitted +# reduce 166 omitted + +# reduce 167 omitted - # reduce 167 omitted +# reduce 168 omitted - # reduce 168 omitted +# reduce 169 omitted - # reduce 169 omitted +# reduce 170 omitted - # reduce 170 omitted +# reduce 171 omitted - # reduce 171 omitted +# reduce 172 omitted - # reduce 172 omitted +module_eval(<<'.,.,', 'grammar.ra', 626) + def _reduce_173(val, _values, result) + result = ast AST::Default, :value => val[0][:value], :line => val[0][:line] -module_eval <<'.,.,', 'grammar.ra', 658 - def _reduce_173( val, _values, result ) - result = ast AST::Default, :value => val[0][:value], :line => val[0][:line] - result + result end .,., - # reduce 174 omitted +# reduce 174 omitted -module_eval <<'.,.,', 'grammar.ra', 661 - def _reduce_175( val, _values, result ) - result = [val[0][:value]] - result +module_eval(<<'.,.,', 'grammar.ra', 631) + def _reduce_175(val, _values, result) + result = [val[0][:value]] + result end .,., - # reduce 176 omitted +# reduce 176 omitted -module_eval <<'.,.,', 'grammar.ra', 663 - def _reduce_177( val, _values, result ) - result = val[0] += val[2] - result +module_eval(<<'.,.,', 'grammar.ra', 633) + def _reduce_177(val, _values, result) + result = val[0] += val[2] + result end .,., -module_eval <<'.,.,', 'grammar.ra', 672 - def _reduce_178( val, _values, result ) - val[1].each do |file| - import(file) - end +module_eval(<<'.,.,', 'grammar.ra', 636) + def _reduce_178(val, _values, result) + val[1].each do |file| + import(file) + end - result = AST::ASTArray.new(:children => []) - result + result = AST::ASTArray.new(:children => []) + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 683 - def _reduce_179( val, _values, result ) - @lexer.commentpop - newdefine classname(val[1]), :arguments => val[2], :code => val[4], :line => val[0][:line] - @lexer.indefine = false - result = nil +module_eval(<<'.,.,', 'grammar.ra', 646) + def _reduce_179(val, _values, result) + @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 { - result + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 688 - def _reduce_180( val, _values, result ) - @lexer.commentpop - newdefine classname(val[1]), :arguments => val[2], :line => val[0][:line] - @lexer.indefine = false - result = nil - result +module_eval(<<'.,.,', 'grammar.ra', 654) + def _reduce_180(val, _values, result) + @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 + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 697 - def _reduce_181( val, _values, result ) - @lexer.commentpop - # Our class gets defined in the parent namespace, not our own. - @lexer.namepop - newclass classname(val[1]), :arguments => val[2], :parent => val[3], :code => val[5], :line => val[0][:line] - result = nil - result +module_eval(<<'.,.,', 'grammar.ra', 662) + def _reduce_181(val, _values, result) + @lexer.commentpop + # Our class gets defined in the parent namespace, not our own. + @lexer.namepop + val[5].is_a_namespace = true + 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])) + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 703 - def _reduce_182( val, _values, result ) - @lexer.commentpop - # Our class gets defined in the parent namespace, not our own. - @lexer.namepop - newclass classname(val[1]), :arguments => val[2], :parent => val[3], :line => val[0][:line] - result = nil - result +module_eval(<<'.,.,', 'grammar.ra', 670) + def _reduce_182(val, _values, result) + @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])) + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 709 - def _reduce_183( val, _values, result ) - @lexer.commentpop - newnode val[1], :parent => val[2], :code => val[4], :line => val[0][:line] - result = nil - result +module_eval(<<'.,.,', 'grammar.ra', 679) + def _reduce_183(val, _values, result) + @lexer.commentpop + result = Puppet::Parser::AST::Node.new(val[1], + ast_context(true).merge(:parent => val[2], :code => val[4], + :line => val[0][:line])) + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 713 - def _reduce_184( val, _values, result ) - @lexer.commentpop - newnode val[1], :parent => val[2], :line => val[0][:line] - result = nil - result +module_eval(<<'.,.,', 'grammar.ra', 684) + def _reduce_184(val, _values, result) + @lexer.commentpop + result = Puppet::Parser::AST::Node.new(val[1], ast_context(true).merge(:parent => val[2], :line => val[0][:line])) + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 714 - def _reduce_185( val, _values, result ) - result = val[0][:value] - result +module_eval(<<'.,.,', 'grammar.ra', 688) + def _reduce_185(val, _values, result) + result = val[0][:value] + result end .,., -module_eval <<'.,.,', 'grammar.ra', 716 - def _reduce_186( val, _values, result ) - result = val[0][:value] - result +module_eval(<<'.,.,', 'grammar.ra', 690) + def _reduce_186(val, _values, result) + result = val[0][:value] + result end .,., -module_eval <<'.,.,', 'grammar.ra', 717 - def _reduce_187( val, _values, result ) - result = val[0][:value] - result +module_eval(<<'.,.,', 'grammar.ra', 691) + def _reduce_187(val, _values, result) + result = val[0][:value] + result end .,., -module_eval <<'.,.,', 'grammar.ra', 718 - def _reduce_188( val, _values, result ) - result = "class" - result +module_eval(<<'.,.,', 'grammar.ra', 692) + def _reduce_188(val, _values, result) + result = "class" + result end .,., - # reduce 189 omitted +module_eval(<<'.,.,', 'grammar.ra', 697) + def _reduce_189(val, _values, result) + result = [result] -module_eval <<'.,.,', 'grammar.ra', 728 - def _reduce_190( val, _values, result ) - result = val[0] - result = [result] unless result.is_a?(Array) + result + end +.,., + +module_eval(<<'.,.,', 'grammar.ra', 700) + def _reduce_190(val, _values, result) + result = val[0] result << val[2] - result + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 732 - def _reduce_191( val, _values, result ) - result = ast AST::HostName, :value => val[0] - result +module_eval(<<'.,.,', 'grammar.ra', 705) + def _reduce_191(val, _values, result) + result = ast AST::HostName, :value => val[0] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 733 - def _reduce_192( val, _values, result ) - result = val[0][:value] - result +module_eval(<<'.,.,', 'grammar.ra', 708) + def _reduce_192(val, _values, result) + result = val[0][:value] + result end .,., -module_eval <<'.,.,', 'grammar.ra', 734 - def _reduce_193( val, _values, result ) - result = val[0][:value] - result +module_eval(<<'.,.,', 'grammar.ra', 709) + def _reduce_193(val, _values, result) + result = val[0][:value] + result end .,., -module_eval <<'.,.,', 'grammar.ra', 735 - def _reduce_194( val, _values, result ) - result = val[0][:value] - result +module_eval(<<'.,.,', 'grammar.ra', 710) + def _reduce_194(val, _values, result) + result = val[0][:value] + result end .,., - # reduce 195 omitted +# reduce 195 omitted + +module_eval(<<'.,.,', 'grammar.ra', 714) + def _reduce_196(val, _values, result) + result = nil -module_eval <<'.,.,', 'grammar.ra', 741 - def _reduce_196( val, _values, result ) - result = nil - result + result end .,., -module_eval <<'.,.,', 'grammar.ra', 745 - def _reduce_197( val, _values, result ) - result = ast AST::ASTArray, :children => [] - result +module_eval(<<'.,.,', 'grammar.ra', 718) + def _reduce_197(val, _values, result) + result = ast AST::ASTArray, :children => [] + + result end .,., - # reduce 198 omitted +# reduce 198 omitted + +module_eval(<<'.,.,', 'grammar.ra', 723) + def _reduce_199(val, _values, result) + result = nil -module_eval <<'.,.,', 'grammar.ra', 750 - def _reduce_199( val, _values, result ) - result = nil - result + result end .,., -module_eval <<'.,.,', 'grammar.ra', 754 - def _reduce_200( val, _values, result ) - result = val[1] +module_eval(<<'.,.,', 'grammar.ra', 726) + def _reduce_200(val, _values, result) + result = val[1] result = [result] unless result[0].is_a?(Array) - result + + result end .,., - # reduce 201 omitted +# reduce 201 omitted -module_eval <<'.,.,', 'grammar.ra', 761 - def _reduce_202( val, _values, result ) - result = val[0] +module_eval(<<'.,.,', 'grammar.ra', 732) + def _reduce_202(val, _values, result) + result = val[0] result = [result] unless result[0].is_a?(Array) result << val[2] - result + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 766 - def _reduce_203( val, _values, result ) - Puppet.warning addcontext("Deprecation notice: must now include '$' in prototype") - result = [val[0][:value], val[2]] - result +module_eval(<<'.,.,', 'grammar.ra', 738) + def _reduce_203(val, _values, result) + Puppet.warning addcontext("Deprecation notice: must now include '$' in prototype") + result = [val[0][:value], val[2]] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 770 - def _reduce_204( val, _values, result ) - Puppet.warning addcontext("Deprecation notice: must now include '$' in prototype") +module_eval(<<'.,.,', 'grammar.ra', 742) + def _reduce_204(val, _values, result) + Puppet.warning addcontext("Deprecation notice: must now include '$' in prototype") result = [val[0][:value]] - result + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 772 - def _reduce_205( val, _values, result ) - result = [val[0][:value], val[2]] - result +module_eval(<<'.,.,', 'grammar.ra', 745) + def _reduce_205(val, _values, result) + result = [val[0][:value], val[2]] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 774 - def _reduce_206( val, _values, result ) - result = [val[0][:value]] - result +module_eval(<<'.,.,', 'grammar.ra', 747) + def _reduce_206(val, _values, result) + result = [val[0][:value]] + + result end .,., - # reduce 207 omitted +# reduce 207 omitted -module_eval <<'.,.,', 'grammar.ra', 779 - def _reduce_208( val, _values, result ) - result = val[1] - result +module_eval(<<'.,.,', 'grammar.ra', 752) + def _reduce_208(val, _values, result) + result = val[1] + + result end .,., - # reduce 209 omitted +# reduce 209 omitted -module_eval <<'.,.,', 'grammar.ra', 784 - def _reduce_210( val, _values, result ) - result = val[1] - result +module_eval(<<'.,.,', 'grammar.ra', 757) + def _reduce_210(val, _values, result) + result = val[1] + + result end .,., - # reduce 211 omitted +# reduce 211 omitted - # reduce 212 omitted +# reduce 212 omitted -module_eval <<'.,.,', 'grammar.ra', 790 - def _reduce_213( val, _values, result ) - result = ast AST::Variable, :value => val[0][:value], :line => val[0][:line] - result +module_eval(<<'.,.,', 'grammar.ra', 763) + def _reduce_213(val, _values, result) + result = ast AST::Variable, :value => val[0][:value], :line => val[0][:line] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 798 - def _reduce_214( val, _values, result ) - if val[1].instance_of?(AST::ASTArray) - result = val[1] - else - result = ast AST::ASTArray, :children => [val[1]] - end - result +module_eval(<<'.,.,', 'grammar.ra', 767) + def _reduce_214(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', 805 - def _reduce_215( val, _values, result ) - if val[1].instance_of?(AST::ASTArray) - result = val[1] - else - result = ast AST::ASTArray, :children => [val[1]] - end - result +module_eval(<<'.,.,', 'grammar.ra', 774) + def _reduce_215(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', 807 - def _reduce_216( val, _values, result ) - result = ast AST::ASTArray - result +module_eval(<<'.,.,', 'grammar.ra', 780) + def _reduce_216(val, _values, result) + result = ast AST::ASTArray + + result end .,., - # reduce 217 omitted +# reduce 217 omitted - # reduce 218 omitted +# reduce 218 omitted - # reduce 219 omitted +# reduce 219 omitted -module_eval <<'.,.,', 'grammar.ra', 812 - def _reduce_220( val, _values, result ) - result = nil - result +module_eval(<<'.,.,', 'grammar.ra', 787) + def _reduce_220(val, _values, result) + result = nil + result end .,., -module_eval <<'.,.,', 'grammar.ra', 817 - def _reduce_221( val, _values, result ) - result = ast AST::Regex, :value => val[0][:value] - result +module_eval(<<'.,.,', 'grammar.ra', 790) + def _reduce_221(val, _values, result) + result = ast AST::Regex, :value => val[0][:value] + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 825 - def _reduce_222( val, _values, result ) - if val[1].instance_of?(AST::ASTHash) - result = val[1] - else - result = ast AST::ASTHash, { :value => val[1] } - end - result +module_eval(<<'.,.,', 'grammar.ra', 794) + def _reduce_222(val, _values, result) + if val[1].instance_of?(AST::ASTHash) + result = val[1] + else + result = ast AST::ASTHash, { :value => val[1] } end -.,., -module_eval <<'.,.,', 'grammar.ra', 832 - def _reduce_223( val, _values, result ) - if val[1].instance_of?(AST::ASTHash) - result = val[1] - else - result = ast AST::ASTHash, { :value => val[1] } - end - result + result end .,., -module_eval <<'.,.,', 'grammar.ra', 834 - def _reduce_224( val, _values, result ) - result = ast AST::ASTHash - result +module_eval(<<'.,.,', 'grammar.ra', 801) + def _reduce_223(val, _values, result) + if val[1].instance_of?(AST::ASTHash) + result = val[1] + else + result = ast AST::ASTHash, { :value => val[1] } + end + + result end .,., - # reduce 225 omitted +module_eval(<<'.,.,', 'grammar.ra', 807) + def _reduce_224(val, _values, result) + result = ast AST::ASTHash -module_eval <<'.,.,', 'grammar.ra', 844 - def _reduce_226( val, _values, result ) - 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 - result + result end .,., -module_eval <<'.,.,', 'grammar.ra', 848 - def _reduce_227( val, _values, result ) - result = ast AST::ASTHash, { :value => { val[0] => val[2] } } - result +# reduce 225 omitted + +module_eval(<<'.,.,', 'grammar.ra', 812) + def _reduce_226(val, _values, result) + 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 + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 849 - def _reduce_228( val, _values, result ) - result = val[0][:value] - result +module_eval(<<'.,.,', 'grammar.ra', 821) + def _reduce_227(val, _values, result) + result = ast AST::ASTHash, { :value => { val[0] => val[2] } } + + result end .,., -module_eval <<'.,.,', 'grammar.ra', 850 - def _reduce_229( val, _values, result ) - result = val[0] - result +module_eval(<<'.,.,', 'grammar.ra', 824) + def _reduce_228(val, _values, result) + result = val[0][:value] + result end .,., -module_eval <<'.,.,', 'grammar.ra', 855 - def _reduce_230( val, _values, result ) - result = ast AST::HashOrArrayAccess, :variable => val[0][:value], :key => val[2] - result +module_eval(<<'.,.,', 'grammar.ra', 825) + def _reduce_229(val, _values, result) + result = val[0] + result end .,., - # reduce 231 omitted +module_eval(<<'.,.,', 'grammar.ra', 828) + def _reduce_230(val, _values, result) + result = ast AST::HashOrArrayAccess, :variable => val[0][:value], :key => val[2] -module_eval <<'.,.,', 'grammar.ra', 860 - def _reduce_232( val, _values, result ) - result = ast AST::HashOrArrayAccess, :variable => val[0], :key => val[2] - result + result end .,., - def _reduce_none( val, _values, result ) - result - end +# reduce 231 omitted - end # class Parser +module_eval(<<'.,.,', 'grammar.ra', 833) + def _reduce_232(val, _values, result) + result = ast AST::HashOrArrayAccess, :variable => val[0], :key => val[2] + + result + end +.,., - end # module Parser +def _reduce_none(val, _values, result) + val[0] +end -end # module Puppet + end # class Parser + end # module Parser + end # module Puppet diff --git a/lib/puppet/parser/parser_support.rb b/lib/puppet/parser/parser_support.rb index 97d985cfb..859897a16 100644 --- a/lib/puppet/parser/parser_support.rb +++ b/lib/puppet/parser/parser_support.rb @@ -133,26 +133,6 @@ class Puppet::Parser::Parser return ns, n end - # Create a new class, or merge with an existing class. - def newclass(name, options = {}) - known_resource_types.add Puppet::Resource::Type.new(:hostclass, name, ast_context(true).merge(options)) - end - - # Create a new definition. - def newdefine(name, options = {}) - known_resource_types.add Puppet::Resource::Type.new(:definition, name, ast_context(true).merge(options)) - end - - # Create a new node. Nodes are special, because they're stored in a global - # table, not according to namespaces. - def newnode(names, options = {}) - names = [names] unless names.instance_of?(Array) - context = ast_context(true) - names.collect do |name| - known_resource_types.add(Puppet::Resource::Type.new(:node, name, context.merge(options))) - end - end - def on_error(token,value,stack) if token == 0 # denotes end of file value = 'end of file' @@ -174,42 +154,43 @@ class Puppet::Parser::Parser # how should I do error handling here? def parse(string = nil) - return parse_ruby_file if self.file =~ /\.rb$/ - self.string = string if string - begin - @yydebug = false - 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. - newclass("", :code => main) + if self.file =~ /\.rb$/ + parse_ruby_file + main = nil + else + self.string = string if string + begin + @yydebug = false + 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 end - return known_resource_types + # Store the results as the top-level class. + return Puppet::Parser::AST::Hostclass.new('', :code => main) ensure @lexer.clear end diff --git a/lib/puppet/parser/type_loader.rb b/lib/puppet/parser/type_loader.rb index 516c1e32b..8a183f493 100644 --- a/lib/puppet/parser/type_loader.rb +++ b/lib/puppet/parser/type_loader.rb @@ -47,17 +47,19 @@ class Puppet::Parser::TypeLoader raise Puppet::ImportError.new("No file(s) found for import of '#{pat}'") end + loaded_asts = [] files.each do |file| unless file =~ /^#{File::SEPARATOR}/ file = File.join(dir, file) end unless imported? file @imported[file] = true - parse_file(file) + loaded_asts << parse_file(file) end end - - modname + loaded_asts.inject([]) do |loaded_types, ast| + loaded_types + known_resource_types.import_ast(ast, modname) + end end def imported?(file) @@ -76,23 +78,26 @@ class Puppet::Parser::TypeLoader @imported = {} end - # Try to load the object with the given fully qualified name. For - # each file that was actually loaded, yield(filename, modname). - def try_load_fqname(fqname) + # Try to load the object with the given fully qualified name. + def try_load_fqname(type, fqname) return nil if fqname == "" # special-case main. name2files(fqname).each do |filename| if not loaded?(filename) - modname = begin - import_if_possible(filename) + begin + imported_types = import_if_possible(filename) + if result = imported_types.find { |t| t.type == type and t.name == fqname } + Puppet.debug "Automatically imported #{fqname} from #{filename} into #{environment}" + return result + end rescue Puppet::ImportError => detail # We couldn't load the item # I'm not convienced we should just drop these errors, but this # preserves existing behaviours. - nil end - yield(filename, modname) end end + # Nothing found. + return nil end def loaded?(name) @@ -103,7 +108,7 @@ class Puppet::Parser::TypeLoader Puppet.debug("importing '#{file}' in environment #{environment}") parser = Puppet::Parser::Parser.new(environment) parser.file = file - parser.parse + return parser.parse end # Utility method factored out of load for handling thread-safety. diff --git a/lib/puppet/resource/type.rb b/lib/puppet/resource/type.rb index 6296d26e5..57ccba58b 100644 --- a/lib/puppet/resource/type.rb +++ b/lib/puppet/resource/type.rb @@ -13,8 +13,8 @@ class Puppet::Resource::Type RESOURCE_SUPERTYPES = [:hostclass, :node, :definition] - attr_accessor :file, :line, :doc, :code, :ruby_code, :parent, :resource_type_collection, :module_name - attr_reader :type, :namespace, :arguments, :behaves_like + attr_accessor :file, :line, :doc, :code, :ruby_code, :parent, :resource_type_collection + attr_reader :type, :namespace, :arguments, :behaves_like, :module_name RESOURCE_SUPERTYPES.each do |t| define_method("#{t}?") { self.type == t } @@ -91,6 +91,8 @@ class Puppet::Resource::Type end set_arguments(options[:arguments]) + + @module_name = options[:module_name] end # This is only used for node names, and really only when the node name diff --git a/lib/puppet/resource/type_collection.rb b/lib/puppet/resource/type_collection.rb index 4254b037e..a96927613 100644 --- a/lib/puppet/resource/type_collection.rb +++ b/lib/puppet/resource/type_collection.rb @@ -19,6 +19,12 @@ class Puppet::Resource::TypeCollection @watched_files = {} end + def import_ast(ast, modname) + ast.instantiate(modname).each do |instance| + add(instance) + end + end + def <<(thing) add(thing) self @@ -177,16 +183,9 @@ class Puppet::Resource::TypeCollection # necessary. def find_or_load(namespaces, name, type) resolve_namespaces(namespaces, name).each do |fqname| - if result = send(type, fqname) + if result = send(type, fqname) || loader.try_load_fqname(type, fqname) return result end - loader.try_load_fqname(fqname) do |filename, modname| - if result = send(type, fqname) - Puppet.debug "Automatically imported #{name} from #{filename} into #{environment}" - result.module_name = modname if modname and result.respond_to?(:module_name=) - return result - end - end end # Nothing found. diff --git a/lib/puppet/util/rdoc/parser.rb b/lib/puppet/util/rdoc/parser.rb index 63df38ab9..30da607d9 100644 --- a/lib/puppet/util/rdoc/parser.rb +++ b/lib/puppet/util/rdoc/parser.rb @@ -17,7 +17,7 @@ class Parser SITE = "__site__" - attr_accessor :ast, :input_file_name, :top_level + attr_accessor :input_file_name, :top_level # parser registration into RDoc parse_files_matching(/\.(rb|pp)$/) @@ -36,8 +36,12 @@ class Parser Puppet.info "rdoc: scanning #{@input_file_name}" if @input_file_name =~ /\.pp$/ @parser = Puppet::Parser::Parser.new(Puppet[:environment]) + environment = @parser.environment @parser.file = @input_file_name - @ast = @parser.parse + @known_resource_types = environment.known_resource_types + @parser.parse.instantiate('').each do |type| + @known_resource_types.add type + end end scan_top_level(@top_level) @top_level @@ -334,7 +338,7 @@ class Parser # that contains the documentation def parse_elements(container) Puppet.debug "rdoc: scanning manifest" - @ast.hostclasses.values.sort { |a,b| a.name <=> b.name }.each do |klass| + @known_resource_types.hostclasses.values.sort { |a,b| a.name <=> b.name }.each do |klass| name = klass.name if klass.file == @input_file_name unless name.empty? @@ -347,13 +351,13 @@ class Parser end end - @ast.definitions.each do |name, define| + @known_resource_types.definitions.each do |name, define| if define.file == @input_file_name document_define(name,define,container) end end - @ast.nodes.each do |name, node| + @known_resource_types.nodes.each do |name, node| if node.file == @input_file_name document_node(name.to_s,node,container) end -- cgit From 50fd9b77cdb2346ec0b760364841abd4eb6f23ff Mon Sep 17 00:00:00 2001 From: Paul Berry Date: Thu, 19 Aug 2010 09:40:15 -0700 Subject: Fixed issue #4570 (Race conditions when serializing objects to YAML). The ZAML class was using class variables to keep track of labels and backreferences while serializing object to YAML. This made it possible to get ill-formed or incorrect YAML output if two threads tried to serialize objects at the same time. Changed to use instance variables of the ZAML class, so there is no race condition. Also added some more spec tests to verify that labels are generated properly. --- lib/puppet/util/zaml.rb | 23 +++++++++++------------ 1 file changed, 11 insertions(+), 12 deletions(-) (limited to 'lib') diff --git a/lib/puppet/util/zaml.rb b/lib/puppet/util/zaml.rb index 8ecc2c8bd..b60e639ff 100644 --- a/lib/puppet/util/zaml.rb +++ b/lib/puppet/util/zaml.rb @@ -29,7 +29,8 @@ class ZAML @result = [] @indent = nil @structured_key_prefix = nil - Label.counter_reset + @previously_emitted_object = {} + @next_free_label_number = 0 emit('--- ') end def nested(tail=' ') @@ -55,31 +56,29 @@ class ZAML # which we will encounter a reference to the object as we serialize # it can be handled). # - def self.counter_reset - @@previously_emitted_object = {} - @@next_free_label_number = 0 - end + attr_accessor :this_label_number def initialize(obj,indent) @indent = indent @this_label_number = nil - @@previously_emitted_object[obj.object_id] = self end def to_s @this_label_number ? ('&id%03d%s' % [@this_label_number, @indent]) : '' end def reference - @this_label_number ||= (@@next_free_label_number += 1) @reference ||= '*id%03d' % @this_label_number end - def self.for(obj) - @@previously_emitted_object[obj.object_id] - end + end + def label_for(obj) + @previously_emitted_object[obj.object_id] end def new_label_for(obj) - Label.new(obj,(Hash === obj || Array === obj) ? "#{@indent || "\n"} " : ' ') + label = Label.new(obj,(Hash === obj || Array === obj) ? "#{@indent || "\n"} " : ' ') + @previously_emitted_object[obj.object_id] = label + label end def first_time_only(obj) - if label = Label.for(obj) + if label = label_for(obj) + label.this_label_number ||= (@next_free_label_number += 1) emit(label.reference) else if @structured_key_prefix and not obj.is_a? String -- cgit From df088c9ba16dce50c17a79920c1ac186db67b9e9 Mon Sep 17 00:00:00 2001 From: Paul Berry Date: Wed, 25 Aug 2010 11:29:23 -0700 Subject: [4638] Cleanup of plurals and inheritance relationships in AST Changed the grammar so that the following "plural" constructs always parse as an ASTArray: - funcvalues - rvalues - resourceinstances - anyparams - params - caseopts - casevalues And the following "singluar" construct never parses as an ASTArray: - statement The previous behavior was for these constructs to parse as a scalar when they represented a single item and an ASTArray when they contained zero or multiple items. ("Statement" could sometimes represent a single item because a single resource declaration could represent multiple resources). This complicated other grammar rules and caused ambiguous handling of nested arrays. Also made these changes to the AST class hierarchy: - ResourceInstance no longer derives from ASTArray. This relationship was not meaningful because a ResourceInstance is a (title, parameters) pair, not an array, and it produced complications when we wanted to represent an array of ResourceInstance objects. - Resource no longer derives from ResourceReference. No significant functionality was being inherited and the relationship doesn't make sense in an AST context. - ResourceOverride no longer derives from Resource. No significant functionality was being inherited and the relationship doesn't make sense in an AST context. - Resource can now represent a compound resource instance such as "notify { foo: ; bar: }". This saves the parser from having to use represent a statement as an array of objects. - ASTArray's evaluate method never flattens out arrays of arrays. --- lib/puppet/parser/ast.rb | 1 + lib/puppet/parser/ast/astarray.rb | 34 +-- lib/puppet/parser/ast/caseopt.rb | 36 +-- lib/puppet/parser/ast/resource.rb | 93 +++--- lib/puppet/parser/ast/resource_instance.rb | 9 + lib/puppet/parser/ast/resource_override.rb | 5 +- lib/puppet/parser/grammar.ra | 131 ++------- lib/puppet/parser/parser.rb | 454 +++++++++++++---------------- lib/puppet/parser/parser_support.rb | 15 +- 9 files changed, 315 insertions(+), 463 deletions(-) create mode 100644 lib/puppet/parser/ast/resource_instance.rb (limited to 'lib') diff --git a/lib/puppet/parser/ast.rb b/lib/puppet/parser/ast.rb index 0369a6d28..03891160b 100644 --- a/lib/puppet/parser/ast.rb +++ b/lib/puppet/parser/ast.rb @@ -129,6 +129,7 @@ require 'puppet/parser/ast/not' require 'puppet/parser/ast/relationship' require 'puppet/parser/ast/resource' require 'puppet/parser/ast/resource_defaults' +require 'puppet/parser/ast/resource_instance' require 'puppet/parser/ast/resource_override' require 'puppet/parser/ast/resource_reference' require 'puppet/parser/ast/resourceparam' diff --git a/lib/puppet/parser/ast/astarray.rb b/lib/puppet/parser/ast/astarray.rb index 432300c7a..b62c820ca 100644 --- a/lib/puppet/parser/ast/astarray.rb +++ b/lib/puppet/parser/ast/astarray.rb @@ -21,22 +21,8 @@ class Puppet::Parser::AST # Evaluate our children. def evaluate(scope) - # Make a new array, so we don't have to deal with the details of - # flattening and such - items = [] - - # First clean out any AST::ASTArrays - @children.each { |child| - if child.instance_of?(AST::ASTArray) - child.each do |ac| - items << ac - end - else - items << child - end - } - - rets = items.flatten.collect { |child| + result = [] + @children.each do |child| if child.respond_to? :instantiate if is_a_namespace # no problem, just don't evaluate it. @@ -48,10 +34,14 @@ class Puppet::Parser::AST raise error end else - child.safeevaluate(scope) + item = child.safeevaluate(scope) + if !item.nil? + # nil values are implicitly removed. + result.push(item) + end end - } - rets.reject { |o| o.nil? } + end + result end def push(*ary) @@ -69,10 +59,4 @@ class Puppet::Parser::AST "[" + @children.collect { |c| c.to_s }.join(', ') + "]" end end - - # A simple container class, containing the parameters for an object. - # Used for abstracting the grammar declarations. Basically unnecessary - # except that I kept finding bugs because I had too many arrays that - # meant completely different things. - class ResourceInstance < ASTArray; end end diff --git a/lib/puppet/parser/ast/caseopt.rb b/lib/puppet/parser/ast/caseopt.rb index 4e296e82f..db4c2b024 100644 --- a/lib/puppet/parser/ast/caseopt.rb +++ b/lib/puppet/parser/ast/caseopt.rb @@ -18,16 +18,12 @@ class Puppet::Parser::AST # Cache the @default value. return @default if defined?(@default) - if @value.is_a?(AST::ASTArray) - @value.each { |subval| - if subval.is_a?(AST::Default) - @default = true - break - end - } - else - @default = true if @value.is_a?(AST::Default) - end + @value.each { |subval| + if subval.is_a?(AST::Default) + @default = true + break + end + } @default ||= false @@ -36,23 +32,15 @@ class Puppet::Parser::AST # You can specify a list of values; return each in turn. def eachvalue(scope) - if @value.is_a?(AST::ASTArray) - @value.each { |subval| - yield subval.safeevaluate(scope) - } - else - yield @value.safeevaluate(scope) - end + @value.each { |subval| + yield subval.safeevaluate(scope) + } end def eachopt - if @value.is_a?(AST::ASTArray) - @value.each { |subval| - yield subval - } - else - yield @value - end + @value.each { |subval| + yield subval + } end # Evaluate the actual statements; this only gets called if diff --git a/lib/puppet/parser/ast/resource.rb b/lib/puppet/parser/ast/resource.rb index 0c58538d5..23207149f 100644 --- a/lib/puppet/parser/ast/resource.rb +++ b/lib/puppet/parser/ast/resource.rb @@ -3,26 +3,15 @@ require 'puppet/parser/ast/resource_reference' # Any normal puppet resource declaration. Can point to a definition or a # builtin type. class Puppet::Parser::AST -class Resource < AST::ResourceReference +class Resource < AST::Branch associates_doc - attr_accessor :title, :type, :exported, :virtual - attr_reader :parameters + attr_accessor :type, :instances, :exported, :virtual # Does not actually return an object; instead sets an object # in the current scope. def evaluate(scope) - # Evaluate all of the specified params. - paramobjects = parameters.collect { |param| - param.safeevaluate(scope) - } - - resource_titles = @title.safeevaluate(scope) - - # it's easier to always use an array, even for only one name - resource_titles = [resource_titles] unless resource_titles.is_a?(Array) - # We want virtual to be true if exported is true. We can't # just set :virtual => self.virtual in the initialization, # because sometimes the :virtual attribute is set *after* @@ -30,49 +19,49 @@ class Resource < AST::ResourceReference # is true. Argh, this was a very tough one to track down. virt = self.virtual || self.exported - # This is where our implicit iteration takes place; if someone - # passed an array as the name, then we act just like the called us - # many times. - fully_qualified_type, resource_titles = scope.resolve_type_and_titles(type, resource_titles) + # First level of implicit iteration: build a resource for each + # instance. This handles things like: + # file { '/foo': owner => blah; '/bar': owner => blah } + @instances.collect { |instance| - resource_titles.flatten.collect { |resource_title| - exceptwrap :type => Puppet::ParseError do - resource = Puppet::Parser::Resource.new( - fully_qualified_type, resource_title, - :parameters => paramobjects, - :file => self.file, - :line => self.line, - :exported => self.exported, - :virtual => virt, - :source => scope.source, - :scope => scope, - - :strict => true - ) + # Evaluate all of the specified params. + paramobjects = instance.parameters.collect { |param| + param.safeevaluate(scope) + } - # And then store the resource in the compiler. - # At some point, we need to switch all of this to return - # resources instead of storing them like this. - scope.compiler.add_resource(scope, resource) - resource - end - }.reject { |resource| resource.nil? } - end + resource_titles = instance.title.safeevaluate(scope) + + # it's easier to always use an array, even for only one name + resource_titles = [resource_titles] unless resource_titles.is_a?(Array) + + fully_qualified_type, resource_titles = scope.resolve_type_and_titles(type, resource_titles) + + # Second level of implicit iteration; build a resource for each + # title. This handles things like: + # file { ['/foo', '/bar']: owner => blah } + resource_titles.flatten.collect { |resource_title| + exceptwrap :type => Puppet::ParseError do + resource = Puppet::Parser::Resource.new( + fully_qualified_type, resource_title, + :parameters => paramobjects, + :file => self.file, + :line => self.line, + :exported => self.exported, + :virtual => virt, + :source => scope.source, + :scope => scope, - # Set the parameters for our object. - def parameters=(params) - if params.is_a?(AST::ASTArray) - @parameters = params - else + :strict => true + ) - @parameters = AST::ASTArray.new( - - :line => params.line, - :file => params.file, - - :children => [params] - ) - end + # And then store the resource in the compiler. + # At some point, we need to switch all of this to return + # resources instead of storing them like this. + scope.compiler.add_resource(scope, resource) + resource + end + } + }.flatten.reject { |resource| resource.nil? } end end end diff --git a/lib/puppet/parser/ast/resource_instance.rb b/lib/puppet/parser/ast/resource_instance.rb new file mode 100644 index 000000000..ebfb17bf1 --- /dev/null +++ b/lib/puppet/parser/ast/resource_instance.rb @@ -0,0 +1,9 @@ +require 'puppet/parser/ast/branch' + +class Puppet::Parser::AST + class ResourceInstance < Branch + # A simple container for a parameter for an object. Consists of a + # title and a set of parameters. + attr_accessor :title, :parameters + end +end diff --git a/lib/puppet/parser/ast/resource_override.rb b/lib/puppet/parser/ast/resource_override.rb index e0be889ff..d638202ab 100644 --- a/lib/puppet/parser/ast/resource_override.rb +++ b/lib/puppet/parser/ast/resource_override.rb @@ -3,12 +3,11 @@ require 'puppet/parser/ast/resource' class Puppet::Parser::AST # Set a parameter on a resource specification created somewhere else in the # configuration. The object is responsible for verifying that this is allowed. - class ResourceOverride < Resource + class ResourceOverride < AST::Branch associates_doc - attr_accessor :object - attr_reader :parameters + attr_accessor :object, :parameters # Iterate across all of our children. def each diff --git a/lib/puppet/parser/grammar.ra b/lib/puppet/parser/grammar.ra index 3185c435d..1f1ec158a 100644 --- a/lib/puppet/parser/grammar.ra +++ b/lib/puppet/parser/grammar.ra @@ -35,10 +35,12 @@ program: statements { | nil statements: statement { - result = ast AST::ASTArray, :children => [val[0]] + result = ast AST::ASTArray, :children => (val[0] ? [val[0]] : []) } | statements statement { - val[0].push(val[1]) + if val[1] + val[0].push(val[1]) + end result = val[0] } @@ -70,19 +72,17 @@ relationship_side: resource | resourceref | collection edge: IN_EDGE | OUT_EDGE | IN_EDGE_SUB | OUT_EDGE_SUB fstatement: NAME LPAREN funcvalues RPAREN { - args = aryfy(val[2]) result = ast AST::Function, :name => val[0][:value], :line => val[0][:line], - :arguments => args, + :arguments => val[2], :ftype => :statement } | NAME LPAREN funcvalues COMMA RPAREN { - args = aryfy(val[2]) result = ast AST::Function, :name => val[0][:value], :line => val[0][:line], - :arguments => args, + :arguments => val[2], :ftype => :statement } | NAME LPAREN RPAREN { result = ast AST::Function, @@ -92,29 +92,22 @@ fstatement: NAME LPAREN funcvalues RPAREN { :ftype => :statement } | NAME funcvalues { - args = aryfy(val[1]) result = ast AST::Function, :name => val[0][:value], :line => val[0][:line], - :arguments => args, + :arguments => val[1], :ftype => :statement } -funcvalues: namestring - | resourceref +funcvalues: namestring { result = aryfy(val[0]) } + | resourceref { result = aryfy(val[0]) } | funcvalues COMMA namestring { - result = aryfy(val[0], val[2]) - result.line = @lexer.line - result.file = @lexer.file + val[0].push(val[2]) + result = val[0] } | funcvalues COMMA resourceref { - unless val[0].is_a?(AST::ASTArray) - val[0] = aryfy(val[0]) - end - - val[0].push(val[2]) - - result = val[0] + val[0].push(val[2]) + result = val[0] } # This is *almost* an rvalue, but I couldn't get a full @@ -133,23 +126,7 @@ namestring: name resource: classname LBRACE resourceinstances endsemi RBRACE { @lexer.commentpop - array = val[2] - array = [array] if array.instance_of?(AST::ResourceInstance) - result = ast AST::ASTArray - - # this iterates across each specified resourceinstance - array.each { |instance| - raise Puppet::Dev, "Got something that isn't an instance" unless instance.instance_of?(AST::ResourceInstance) - # now, i need to somehow differentiate between those things with - # arrays in their names, and normal things - - result.push ast( - AST::Resource, - :type => val[0], - :title => instance[0], - - :parameters => instance[1]) - } + 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" @@ -178,14 +155,8 @@ virtualresource: at resource { 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 + # Just mark our resource as exported and pass it through. + val[1].send(method, true) result = val[1] } @@ -284,17 +255,13 @@ colllval: variable | name resourceinst: resourcename COLON params endcomma { - result = ast AST::ResourceInstance, :children => [val[0],val[2]] + result = ast AST::ResourceInstance, :title => val[0], :parameters => val[2] } -resourceinstances: resourceinst +resourceinstances: resourceinst { result = aryfy(val[0]) } | resourceinstances SEMIC resourceinst { - if val[0].instance_of?(AST::ResourceInstance) - result = ast AST::ASTArray, :children => [val[0],val[2]] - else val[0].push val[2] result = val[0] - end } endsemi: # nothing @@ -339,14 +306,10 @@ params: # nothing { result = ast AST::ASTArray } - | param { result = val[0] } + | param { result = aryfy(val[0]) } | params COMMA param { - 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 } param: NAME FARROW rvalue { @@ -365,24 +328,14 @@ anyparams: # nothing { result = ast AST::ASTArray } - | anyparam { result = val[0] } + | anyparam { result = aryfy(val[0]) } | anyparams COMMA anyparam { - 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 } -rvalues: rvalue - | rvalues comma rvalue { - if val[0].instance_of?(AST::ASTArray) - result = val[0].push(val[2]) - else - result = ast AST::ASTArray, :children => [val[0],val[2]] - end -} +rvalues: rvalue { result = aryfy(val[0]) } + | rvalues comma rvalue { result = val[0].push(val[2]) } simplervalue: quotedtext | name @@ -406,10 +359,9 @@ rvalue: quotedtext # We currently require arguments in these functions. funcrvalue: NAME LPAREN funcvalues RPAREN { - args = aryfy(val[2]) result = ast AST::Function, :name => val[0][:value], :line => val[0][:line], - :arguments => args, + :arguments => val[2], :ftype => :rvalue } | NAME LPAREN RPAREN { result = ast AST::Function, @@ -553,19 +505,13 @@ expression: rvalue casestatement: CASE rvalue LBRACE caseopts RBRACE { @lexer.commentpop - options = val[3] - options = ast AST::ASTArray, :children => [val[3]] unless options.instance_of?(AST::ASTArray) - result = ast AST::CaseStatement, :test => val[1], :options => options + result = ast AST::CaseStatement, :test => val[1], :options => val[3] } -caseopts: caseopt +caseopts: caseopt { result = aryfy(val[0]) } | caseopts caseopt { - 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 } caseopt: casevalues COLON LBRACE statements RBRACE { @@ -582,14 +528,10 @@ caseopt: casevalues COLON LBRACE statements RBRACE { ) } -casevalues: selectlhand +casevalues: selectlhand { result = aryfy(val[0]) } | casevalues COMMA selectlhand { - 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 } selector: selectlhand QMARK svalues { @@ -638,7 +580,7 @@ import: IMPORT strings { import(file) end - result = AST::ASTArray.new(:children => []) + result = nil } # Disable definition inheritance for now. 8/27/06, luke @@ -764,22 +706,9 @@ variable: VARIABLE { result = ast AST::Variable, :value => val[0][:value], :line => val[0][:line] } -array: LBRACK rvalues RBRACK { - if val[1].instance_of?(AST::ASTArray) - result = val[1] - else - result = ast AST::ASTArray, :children => [val[1]] - end -} - | LBRACK rvalues COMMA RBRACK { - if val[1].instance_of?(AST::ASTArray) - result = val[1] - else - result = ast AST::ASTArray, :children => [val[1]] - end -} | LBRACK RBRACK { - result = ast AST::ASTArray -} +array: LBRACK rvalues RBRACK { result = val[1] } + | LBRACK rvalues COMMA RBRACK { result = val[1] } + | LBRACK RBRACK { result = ast AST::ASTArray } comma: FARROW | COMMA diff --git a/lib/puppet/parser/parser.rb b/lib/puppet/parser/parser.rb index e4f5149b9..0f851a5a8 100644 --- a/lib/puppet/parser/parser.rb +++ b/lib/puppet/parser/parser.rb @@ -21,7 +21,7 @@ module Puppet module Parser class Parser < Racc::Parser -module_eval(<<'...end grammar.ra/module_eval...', 'grammar.ra', 851) +module_eval(<<'...end grammar.ra/module_eval...', 'grammar.ra', 780) # It got too annoying having code in a file that needs to be compiled. require 'puppet/parser/parser_support' @@ -708,8 +708,8 @@ racc_reduce_table = [ 5, 81, :_reduce_29, 3, 81, :_reduce_30, 2, 81, :_reduce_31, - 1, 91, :_reduce_none, - 1, 91, :_reduce_none, + 1, 91, :_reduce_32, + 1, 91, :_reduce_33, 3, 91, :_reduce_34, 3, 91, :_reduce_35, 1, 92, :_reduce_none, @@ -744,7 +744,7 @@ racc_reduce_table = [ 1, 114, :_reduce_none, 1, 114, :_reduce_none, 4, 116, :_reduce_67, - 1, 102, :_reduce_none, + 1, 102, :_reduce_68, 3, 102, :_reduce_69, 0, 103, :_reduce_none, 1, 103, :_reduce_none, @@ -771,7 +771,7 @@ racc_reduce_table = [ 0, 107, :_reduce_92, 1, 107, :_reduce_93, 3, 107, :_reduce_94, - 1, 126, :_reduce_none, + 1, 126, :_reduce_95, 3, 126, :_reduce_96, 1, 115, :_reduce_none, 1, 115, :_reduce_none, @@ -830,11 +830,11 @@ racc_reduce_table = [ 3, 120, :_reduce_151, 3, 120, :_reduce_152, 5, 78, :_reduce_153, - 1, 134, :_reduce_none, + 1, 134, :_reduce_154, 2, 134, :_reduce_155, 5, 135, :_reduce_156, 4, 135, :_reduce_157, - 1, 136, :_reduce_none, + 1, 136, :_reduce_158, 3, 136, :_reduce_159, 3, 98, :_reduce_160, 1, 138, :_reduce_none, @@ -1182,7 +1182,7 @@ module_eval(<<'.,.,', 'grammar.ra', 31) module_eval(<<'.,.,', 'grammar.ra', 37) def _reduce_3(val, _values, result) - result = ast AST::ASTArray, :children => [val[0]] + result = ast AST::ASTArray, :children => (val[0] ? [val[0]] : []) result end @@ -1190,7 +1190,9 @@ module_eval(<<'.,.,', 'grammar.ra', 37) module_eval(<<'.,.,', 'grammar.ra', 40) def _reduce_4(val, _values, result) - val[0].push(val[1]) + if val[1] + val[0].push(val[1]) + end result = val[0] result @@ -1225,7 +1227,7 @@ module_eval(<<'.,.,', 'grammar.ra', 40) # reduce 18 omitted -module_eval(<<'.,.,', 'grammar.ra', 61) +module_eval(<<'.,.,', 'grammar.ra', 63) def _reduce_19(val, _values, result) result = AST::Relationship.new(val[0], val[2], val[1][:value], ast_context) @@ -1233,7 +1235,7 @@ module_eval(<<'.,.,', 'grammar.ra', 61) end .,., -module_eval(<<'.,.,', 'grammar.ra', 64) +module_eval(<<'.,.,', 'grammar.ra', 66) def _reduce_20(val, _values, result) result = AST::Relationship.new(val[0], val[2], val[1][:value], ast_context) @@ -1255,26 +1257,24 @@ module_eval(<<'.,.,', 'grammar.ra', 64) # reduce 27 omitted -module_eval(<<'.,.,', 'grammar.ra', 72) +module_eval(<<'.,.,', 'grammar.ra', 74) def _reduce_28(val, _values, result) - args = aryfy(val[2]) - result = ast AST::Function, + result = ast AST::Function, :name => val[0][:value], :line => val[0][:line], - :arguments => args, + :arguments => val[2], :ftype => :statement result end .,., -module_eval(<<'.,.,', 'grammar.ra', 80) +module_eval(<<'.,.,', 'grammar.ra', 81) def _reduce_29(val, _values, result) - args = aryfy(val[2]) - result = ast AST::Function, + result = ast AST::Function, :name => val[0][:value], :line => val[0][:line], - :arguments => args, + :arguments => val[2], :ftype => :statement result @@ -1295,40 +1295,43 @@ module_eval(<<'.,.,', 'grammar.ra', 87) module_eval(<<'.,.,', 'grammar.ra', 94) def _reduce_31(val, _values, result) - args = aryfy(val[1]) - result = ast AST::Function, + result = ast AST::Function, :name => val[0][:value], :line => val[0][:line], - :arguments => args, + :arguments => val[1], :ftype => :statement result end .,., -# reduce 32 omitted +module_eval(<<'.,.,', 'grammar.ra', 101) + def _reduce_32(val, _values, result) + result = aryfy(val[0]) + result + end +.,., -# reduce 33 omitted +module_eval(<<'.,.,', 'grammar.ra', 102) + def _reduce_33(val, _values, result) + result = aryfy(val[0]) + result + end +.,., -module_eval(<<'.,.,', 'grammar.ra', 105) +module_eval(<<'.,.,', 'grammar.ra', 104) def _reduce_34(val, _values, result) - result = aryfy(val[0], val[2]) - result.line = @lexer.line - result.file = @lexer.file + val[0].push(val[2]) + result = val[0] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 110) +module_eval(<<'.,.,', 'grammar.ra', 108) def _reduce_35(val, _values, result) - unless val[0].is_a?(AST::ASTArray) - val[0] = aryfy(val[0]) - end - - val[0].push(val[2]) - - result = val[0] + val[0].push(val[2]) + result = val[0] result end @@ -1350,7 +1353,7 @@ module_eval(<<'.,.,', 'grammar.ra', 110) # reduce 43 omitted -module_eval(<<'.,.,', 'grammar.ra', 130) +module_eval(<<'.,.,', 'grammar.ra', 123) def _reduce_44(val, _values, result) result = ast AST::Name, :value => val[0][:value] @@ -1358,32 +1361,16 @@ module_eval(<<'.,.,', 'grammar.ra', 130) end .,., -module_eval(<<'.,.,', 'grammar.ra', 134) +module_eval(<<'.,.,', 'grammar.ra', 127) def _reduce_45(val, _values, result) @lexer.commentpop - array = val[2] - array = [array] if array.instance_of?(AST::ResourceInstance) - result = ast AST::ASTArray - - # this iterates across each specified resourceinstance - array.each { |instance| - raise Puppet::Dev, "Got something that isn't an instance" unless instance.instance_of?(AST::ResourceInstance) - # now, i need to somehow differentiate between those things with - # arrays in their names, and normal things - - result.push ast( - AST::Resource, - :type => val[0], - :title => instance[0], - - :parameters => instance[1]) - } + result = ast(AST::Resource, :type => val[0], :instances => val[2]) result end .,., -module_eval(<<'.,.,', 'grammar.ra', 153) +module_eval(<<'.,.,', 'grammar.ra', 130) def _reduce_46(val, _values, result) # This is a deprecated syntax. error "All resource specifications require names" @@ -1392,7 +1379,7 @@ module_eval(<<'.,.,', 'grammar.ra', 153) end .,., -module_eval(<<'.,.,', 'grammar.ra', 156) +module_eval(<<'.,.,', 'grammar.ra', 133) def _reduce_47(val, _values, result) # a defaults setting for a type @lexer.commentpop @@ -1402,7 +1389,7 @@ module_eval(<<'.,.,', 'grammar.ra', 156) end .,., -module_eval(<<'.,.,', 'grammar.ra', 163) +module_eval(<<'.,.,', 'grammar.ra', 140) def _reduce_48(val, _values, result) @lexer.commentpop result = ast AST::ResourceOverride, :object => val[0], :parameters => val[2] @@ -1411,7 +1398,7 @@ module_eval(<<'.,.,', 'grammar.ra', 163) end .,., -module_eval(<<'.,.,', 'grammar.ra', 170) +module_eval(<<'.,.,', 'grammar.ra', 147) def _reduce_49(val, _values, result) type = val[0] @@ -1423,14 +1410,8 @@ module_eval(<<'.,.,', 'grammar.ra', 170) 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 + # Just mark our resource as exported and pass it through. + val[1].send(method, true) result = val[1] @@ -1438,21 +1419,21 @@ module_eval(<<'.,.,', 'grammar.ra', 170) end .,., -module_eval(<<'.,.,', 'grammar.ra', 192) +module_eval(<<'.,.,', 'grammar.ra', 163) def _reduce_50(val, _values, result) result = :virtual result end .,., -module_eval(<<'.,.,', 'grammar.ra', 193) +module_eval(<<'.,.,', 'grammar.ra', 164) def _reduce_51(val, _values, result) result = :exported result end .,., -module_eval(<<'.,.,', 'grammar.ra', 198) +module_eval(<<'.,.,', 'grammar.ra', 169) def _reduce_52(val, _values, result) @lexer.commentpop Puppet.warning addcontext("Collection names must now be capitalized") if val[0] =~ /^[a-z]/ @@ -1476,7 +1457,7 @@ module_eval(<<'.,.,', 'grammar.ra', 198) end .,., -module_eval(<<'.,.,', 'grammar.ra', 217) +module_eval(<<'.,.,', 'grammar.ra', 188) def _reduce_53(val, _values, result) if val[0] =~ /^[a-z]/ Puppet.warning addcontext("Collection names must now be capitalized") @@ -1500,7 +1481,7 @@ module_eval(<<'.,.,', 'grammar.ra', 217) end .,., -module_eval(<<'.,.,', 'grammar.ra', 238) +module_eval(<<'.,.,', 'grammar.ra', 209) def _reduce_54(val, _values, result) if val[1] result = val[1] @@ -1513,7 +1494,7 @@ module_eval(<<'.,.,', 'grammar.ra', 238) end .,., -module_eval(<<'.,.,', 'grammar.ra', 246) +module_eval(<<'.,.,', 'grammar.ra', 217) def _reduce_55(val, _values, result) if val[1] result = val[1] @@ -1530,7 +1511,7 @@ module_eval(<<'.,.,', 'grammar.ra', 246) # reduce 57 omitted -module_eval(<<'.,.,', 'grammar.ra', 259) +module_eval(<<'.,.,', 'grammar.ra', 230) def _reduce_58(val, _values, result) result = ast AST::CollExpr, :test1 => val[0], :oper => val[1], :test2 => val[2] @@ -1540,7 +1521,7 @@ module_eval(<<'.,.,', 'grammar.ra', 259) # reduce 59 omitted -module_eval(<<'.,.,', 'grammar.ra', 264) +module_eval(<<'.,.,', 'grammar.ra', 235) def _reduce_60(val, _values, result) result = val[1] result.parens = true @@ -1549,21 +1530,21 @@ module_eval(<<'.,.,', 'grammar.ra', 264) end .,., -module_eval(<<'.,.,', 'grammar.ra', 268) +module_eval(<<'.,.,', 'grammar.ra', 239) def _reduce_61(val, _values, result) result=val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 269) +module_eval(<<'.,.,', 'grammar.ra', 240) def _reduce_62(val, _values, result) result=val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 272) +module_eval(<<'.,.,', 'grammar.ra', 243) def _reduce_63(val, _values, result) result = ast AST::CollExpr, :test1 => val[0], :oper => val[1][:value], :test2 => val[2] #result = ast AST::CollExpr @@ -1573,7 +1554,7 @@ module_eval(<<'.,.,', 'grammar.ra', 272) end .,., -module_eval(<<'.,.,', 'grammar.ra', 277) +module_eval(<<'.,.,', 'grammar.ra', 248) def _reduce_64(val, _values, result) result = ast AST::CollExpr, :test1 => val[0], :oper => val[1][:value], :test2 => val[2] #result = ast AST::CollExpr @@ -1587,24 +1568,25 @@ module_eval(<<'.,.,', 'grammar.ra', 277) # reduce 66 omitted -module_eval(<<'.,.,', 'grammar.ra', 286) +module_eval(<<'.,.,', 'grammar.ra', 257) def _reduce_67(val, _values, result) - result = ast AST::ResourceInstance, :children => [val[0],val[2]] + result = ast AST::ResourceInstance, :title => val[0], :parameters => val[2] result end .,., -# reduce 68 omitted +module_eval(<<'.,.,', 'grammar.ra', 260) + def _reduce_68(val, _values, result) + result = aryfy(val[0]) + result + end +.,., -module_eval(<<'.,.,', 'grammar.ra', 291) +module_eval(<<'.,.,', 'grammar.ra', 262) def _reduce_69(val, _values, result) - if val[0].instance_of?(AST::ResourceInstance) - result = ast AST::ASTArray, :children => [val[0],val[2]] - else - val[0].push val[2] + val[0].push val[2] result = val[0] - end result end @@ -1614,7 +1596,7 @@ module_eval(<<'.,.,', 'grammar.ra', 291) # reduce 71 omitted -module_eval(<<'.,.,', 'grammar.ra', 303) +module_eval(<<'.,.,', 'grammar.ra', 270) def _reduce_72(val, _values, result) result = ast AST::Undef, :value => :undef @@ -1622,7 +1604,7 @@ module_eval(<<'.,.,', 'grammar.ra', 303) end .,., -module_eval(<<'.,.,', 'grammar.ra', 307) +module_eval(<<'.,.,', 'grammar.ra', 274) def _reduce_73(val, _values, result) result = ast AST::Name, :value => val[0][:value], :line => val[0][:line] @@ -1630,7 +1612,7 @@ module_eval(<<'.,.,', 'grammar.ra', 307) end .,., -module_eval(<<'.,.,', 'grammar.ra', 311) +module_eval(<<'.,.,', 'grammar.ra', 278) def _reduce_74(val, _values, result) result = ast AST::Type, :value => val[0][:value], :line => val[0][:line] @@ -1652,7 +1634,7 @@ module_eval(<<'.,.,', 'grammar.ra', 311) # reduce 81 omitted -module_eval(<<'.,.,', 'grammar.ra', 323) +module_eval(<<'.,.,', 'grammar.ra', 290) def _reduce_82(val, _values, result) raise Puppet::ParseError, "Cannot assign to variables in other namespaces" if val[0][:value] =~ /::/ # this is distinct from referencing a variable @@ -1663,7 +1645,7 @@ module_eval(<<'.,.,', 'grammar.ra', 323) end .,., -module_eval(<<'.,.,', 'grammar.ra', 329) +module_eval(<<'.,.,', 'grammar.ra', 296) def _reduce_83(val, _values, result) result = ast AST::VarDef, :name => val[0], :value => val[2] @@ -1671,7 +1653,7 @@ module_eval(<<'.,.,', 'grammar.ra', 329) end .,., -module_eval(<<'.,.,', 'grammar.ra', 333) +module_eval(<<'.,.,', 'grammar.ra', 300) def _reduce_84(val, _values, result) 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] @@ -1680,7 +1662,7 @@ module_eval(<<'.,.,', 'grammar.ra', 333) end .,., -module_eval(<<'.,.,', 'grammar.ra', 339) +module_eval(<<'.,.,', 'grammar.ra', 306) def _reduce_85(val, _values, result) result = ast AST::ASTArray @@ -1688,27 +1670,23 @@ module_eval(<<'.,.,', 'grammar.ra', 339) end .,., -module_eval(<<'.,.,', 'grammar.ra', 341) +module_eval(<<'.,.,', 'grammar.ra', 308) def _reduce_86(val, _values, result) - result = val[0] + result = aryfy(val[0]) result end .,., -module_eval(<<'.,.,', 'grammar.ra', 343) +module_eval(<<'.,.,', 'grammar.ra', 310) def _reduce_87(val, _values, result) - if val[0].instance_of?(AST::ASTArray) - val[0].push(val[2]) + 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', 352) +module_eval(<<'.,.,', 'grammar.ra', 315) def _reduce_88(val, _values, result) result = ast AST::ResourceParam, :param => val[0][:value], :line => val[0][:line], :value => val[2] @@ -1716,7 +1694,7 @@ module_eval(<<'.,.,', 'grammar.ra', 352) end .,., -module_eval(<<'.,.,', 'grammar.ra', 356) +module_eval(<<'.,.,', 'grammar.ra', 319) def _reduce_89(val, _values, result) result = ast AST::ResourceParam, :param => val[0][:value], :line => val[0][:line], :value => val[2], :add => true @@ -1729,7 +1707,7 @@ module_eval(<<'.,.,', 'grammar.ra', 356) # reduce 91 omitted -module_eval(<<'.,.,', 'grammar.ra', 365) +module_eval(<<'.,.,', 'grammar.ra', 328) def _reduce_92(val, _values, result) result = ast AST::ASTArray @@ -1737,36 +1715,32 @@ module_eval(<<'.,.,', 'grammar.ra', 365) end .,., -module_eval(<<'.,.,', 'grammar.ra', 367) +module_eval(<<'.,.,', 'grammar.ra', 330) def _reduce_93(val, _values, result) - result = val[0] + result = aryfy(val[0]) result end .,., -module_eval(<<'.,.,', 'grammar.ra', 369) +module_eval(<<'.,.,', 'grammar.ra', 332) def _reduce_94(val, _values, result) - if val[0].instance_of?(AST::ASTArray) - val[0].push(val[2]) + val[0].push(val[2]) result = val[0] - else - result = ast AST::ASTArray, :children => [val[0],val[2]] - end result end .,., -# reduce 95 omitted - -module_eval(<<'.,.,', 'grammar.ra', 379) - def _reduce_96(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]] +module_eval(<<'.,.,', 'grammar.ra', 336) + def _reduce_95(val, _values, result) + result = aryfy(val[0]) + result end +.,., +module_eval(<<'.,.,', 'grammar.ra', 337) + def _reduce_96(val, _values, result) + result = val[0].push(val[2]) result end .,., @@ -1807,19 +1781,18 @@ module_eval(<<'.,.,', 'grammar.ra', 379) # reduce 114 omitted -module_eval(<<'.,.,', 'grammar.ra', 408) +module_eval(<<'.,.,', 'grammar.ra', 361) def _reduce_115(val, _values, result) - args = aryfy(val[2]) - result = ast AST::Function, + result = ast AST::Function, :name => val[0][:value], :line => val[0][:line], - :arguments => args, + :arguments => val[2], :ftype => :rvalue result end .,., -module_eval(<<'.,.,', 'grammar.ra', 414) +module_eval(<<'.,.,', 'grammar.ra', 366) def _reduce_116(val, _values, result) result = ast AST::Function, :name => val[0][:value], :line => val[0][:line], @@ -1830,42 +1803,42 @@ module_eval(<<'.,.,', 'grammar.ra', 414) end .,., -module_eval(<<'.,.,', 'grammar.ra', 420) +module_eval(<<'.,.,', 'grammar.ra', 372) def _reduce_117(val, _values, result) result = ast AST::String, :value => val[0][:value], :line => val[0][:line] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 421) +module_eval(<<'.,.,', 'grammar.ra', 373) def _reduce_118(val, _values, result) result = ast AST::Concat, :value => [ast(AST::String,val[0])]+val[1], :line => val[0][:line] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 423) +module_eval(<<'.,.,', 'grammar.ra', 375) def _reduce_119(val, _values, result) result = [val[0]] + val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 425) +module_eval(<<'.,.,', 'grammar.ra', 377) def _reduce_120(val, _values, result) result = [ast(AST::String,val[0])] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 426) +module_eval(<<'.,.,', 'grammar.ra', 378) def _reduce_121(val, _values, result) result = [ast(AST::String,val[0])] + val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 429) +module_eval(<<'.,.,', 'grammar.ra', 381) def _reduce_122(val, _values, result) result = ast AST::Boolean, :value => val[0][:value], :line => val[0][:line] @@ -1873,7 +1846,7 @@ module_eval(<<'.,.,', 'grammar.ra', 429) end .,., -module_eval(<<'.,.,', 'grammar.ra', 433) +module_eval(<<'.,.,', 'grammar.ra', 385) def _reduce_123(val, _values, result) 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] @@ -1882,7 +1855,7 @@ module_eval(<<'.,.,', 'grammar.ra', 433) end .,., -module_eval(<<'.,.,', 'grammar.ra', 436) +module_eval(<<'.,.,', 'grammar.ra', 388) def _reduce_124(val, _values, result) result = ast AST::ResourceReference, :type => val[0], :title => val[2] @@ -1890,7 +1863,7 @@ module_eval(<<'.,.,', 'grammar.ra', 436) end .,., -module_eval(<<'.,.,', 'grammar.ra', 440) +module_eval(<<'.,.,', 'grammar.ra', 392) def _reduce_125(val, _values, result) result = val[1] @@ -1898,7 +1871,7 @@ module_eval(<<'.,.,', 'grammar.ra', 440) end .,., -module_eval(<<'.,.,', 'grammar.ra', 444) +module_eval(<<'.,.,', 'grammar.ra', 396) def _reduce_126(val, _values, result) @lexer.commentpop args = { @@ -1914,7 +1887,7 @@ module_eval(<<'.,.,', 'grammar.ra', 444) end .,., -module_eval(<<'.,.,', 'grammar.ra', 455) +module_eval(<<'.,.,', 'grammar.ra', 407) def _reduce_127(val, _values, result) @lexer.commentpop args = { @@ -1932,7 +1905,7 @@ module_eval(<<'.,.,', 'grammar.ra', 455) # reduce 128 omitted -module_eval(<<'.,.,', 'grammar.ra', 468) +module_eval(<<'.,.,', 'grammar.ra', 420) def _reduce_129(val, _values, result) result = ast AST::Else, :statements => val[1] @@ -1940,7 +1913,7 @@ module_eval(<<'.,.,', 'grammar.ra', 468) end .,., -module_eval(<<'.,.,', 'grammar.ra', 471) +module_eval(<<'.,.,', 'grammar.ra', 423) def _reduce_130(val, _values, result) @lexer.commentpop result = ast AST::Else, :statements => val[2] @@ -1949,7 +1922,7 @@ module_eval(<<'.,.,', 'grammar.ra', 471) end .,., -module_eval(<<'.,.,', 'grammar.ra', 475) +module_eval(<<'.,.,', 'grammar.ra', 427) def _reduce_131(val, _values, result) @lexer.commentpop result = ast AST::Else, :statements => ast(AST::Nop) @@ -1960,7 +1933,7 @@ module_eval(<<'.,.,', 'grammar.ra', 475) # reduce 132 omitted -module_eval(<<'.,.,', 'grammar.ra', 493) +module_eval(<<'.,.,', 'grammar.ra', 445) def _reduce_133(val, _values, result) result = ast AST::InOperator, :lval => val[0], :rval => val[2] @@ -1968,7 +1941,7 @@ module_eval(<<'.,.,', 'grammar.ra', 493) end .,., -module_eval(<<'.,.,', 'grammar.ra', 496) +module_eval(<<'.,.,', 'grammar.ra', 448) def _reduce_134(val, _values, result) result = ast AST::MatchOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -1976,7 +1949,7 @@ module_eval(<<'.,.,', 'grammar.ra', 496) end .,., -module_eval(<<'.,.,', 'grammar.ra', 499) +module_eval(<<'.,.,', 'grammar.ra', 451) def _reduce_135(val, _values, result) result = ast AST::MatchOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -1984,7 +1957,7 @@ module_eval(<<'.,.,', 'grammar.ra', 499) end .,., -module_eval(<<'.,.,', 'grammar.ra', 502) +module_eval(<<'.,.,', 'grammar.ra', 454) def _reduce_136(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -1992,7 +1965,7 @@ module_eval(<<'.,.,', 'grammar.ra', 502) end .,., -module_eval(<<'.,.,', 'grammar.ra', 505) +module_eval(<<'.,.,', 'grammar.ra', 457) def _reduce_137(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2000,7 +1973,7 @@ module_eval(<<'.,.,', 'grammar.ra', 505) end .,., -module_eval(<<'.,.,', 'grammar.ra', 508) +module_eval(<<'.,.,', 'grammar.ra', 460) def _reduce_138(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2008,7 +1981,7 @@ module_eval(<<'.,.,', 'grammar.ra', 508) end .,., -module_eval(<<'.,.,', 'grammar.ra', 511) +module_eval(<<'.,.,', 'grammar.ra', 463) def _reduce_139(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2016,7 +1989,7 @@ module_eval(<<'.,.,', 'grammar.ra', 511) end .,., -module_eval(<<'.,.,', 'grammar.ra', 514) +module_eval(<<'.,.,', 'grammar.ra', 466) def _reduce_140(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2024,7 +1997,7 @@ module_eval(<<'.,.,', 'grammar.ra', 514) end .,., -module_eval(<<'.,.,', 'grammar.ra', 517) +module_eval(<<'.,.,', 'grammar.ra', 469) def _reduce_141(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2032,7 +2005,7 @@ module_eval(<<'.,.,', 'grammar.ra', 517) end .,., -module_eval(<<'.,.,', 'grammar.ra', 520) +module_eval(<<'.,.,', 'grammar.ra', 472) def _reduce_142(val, _values, result) result = ast AST::Minus, :value => val[1] @@ -2040,7 +2013,7 @@ module_eval(<<'.,.,', 'grammar.ra', 520) end .,., -module_eval(<<'.,.,', 'grammar.ra', 523) +module_eval(<<'.,.,', 'grammar.ra', 475) def _reduce_143(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2048,7 +2021,7 @@ module_eval(<<'.,.,', 'grammar.ra', 523) end .,., -module_eval(<<'.,.,', 'grammar.ra', 526) +module_eval(<<'.,.,', 'grammar.ra', 478) def _reduce_144(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2056,7 +2029,7 @@ module_eval(<<'.,.,', 'grammar.ra', 526) end .,., -module_eval(<<'.,.,', 'grammar.ra', 529) +module_eval(<<'.,.,', 'grammar.ra', 481) def _reduce_145(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2064,7 +2037,7 @@ module_eval(<<'.,.,', 'grammar.ra', 529) end .,., -module_eval(<<'.,.,', 'grammar.ra', 532) +module_eval(<<'.,.,', 'grammar.ra', 484) def _reduce_146(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2072,7 +2045,7 @@ module_eval(<<'.,.,', 'grammar.ra', 532) end .,., -module_eval(<<'.,.,', 'grammar.ra', 535) +module_eval(<<'.,.,', 'grammar.ra', 487) def _reduce_147(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2080,7 +2053,7 @@ module_eval(<<'.,.,', 'grammar.ra', 535) end .,., -module_eval(<<'.,.,', 'grammar.ra', 538) +module_eval(<<'.,.,', 'grammar.ra', 490) def _reduce_148(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2088,7 +2061,7 @@ module_eval(<<'.,.,', 'grammar.ra', 538) end .,., -module_eval(<<'.,.,', 'grammar.ra', 541) +module_eval(<<'.,.,', 'grammar.ra', 493) def _reduce_149(val, _values, result) result = ast AST::Not, :value => val[1] @@ -2096,7 +2069,7 @@ module_eval(<<'.,.,', 'grammar.ra', 541) end .,., -module_eval(<<'.,.,', 'grammar.ra', 544) +module_eval(<<'.,.,', 'grammar.ra', 496) def _reduce_150(val, _values, result) result = ast AST::BooleanOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2104,7 +2077,7 @@ module_eval(<<'.,.,', 'grammar.ra', 544) end .,., -module_eval(<<'.,.,', 'grammar.ra', 547) +module_eval(<<'.,.,', 'grammar.ra', 499) def _reduce_151(val, _values, result) result = ast AST::BooleanOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2112,7 +2085,7 @@ module_eval(<<'.,.,', 'grammar.ra', 547) end .,., -module_eval(<<'.,.,', 'grammar.ra', 550) +module_eval(<<'.,.,', 'grammar.ra', 502) def _reduce_152(val, _values, result) result = val[1] @@ -2120,33 +2093,32 @@ module_eval(<<'.,.,', 'grammar.ra', 550) end .,., -module_eval(<<'.,.,', 'grammar.ra', 554) +module_eval(<<'.,.,', 'grammar.ra', 506) def _reduce_153(val, _values, result) @lexer.commentpop - options = val[3] - options = ast AST::ASTArray, :children => [val[3]] unless options.instance_of?(AST::ASTArray) - result = ast AST::CaseStatement, :test => val[1], :options => options + result = ast AST::CaseStatement, :test => val[1], :options => val[3] result end .,., -# reduce 154 omitted +module_eval(<<'.,.,', 'grammar.ra', 510) + def _reduce_154(val, _values, result) + result = aryfy(val[0]) + result + end +.,., -module_eval(<<'.,.,', 'grammar.ra', 562) +module_eval(<<'.,.,', 'grammar.ra', 512) def _reduce_155(val, _values, result) - if val[0].instance_of?(AST::ASTArray) - val[0].push val[1] + 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', 571) +module_eval(<<'.,.,', 'grammar.ra', 517) def _reduce_156(val, _values, result) @lexer.commentpop result = ast AST::CaseOpt, :value => val[0], :statements => val[3] @@ -2155,7 +2127,7 @@ module_eval(<<'.,.,', 'grammar.ra', 571) end .,., -module_eval(<<'.,.,', 'grammar.ra', 574) +module_eval(<<'.,.,', 'grammar.ra', 520) def _reduce_157(val, _values, result) @lexer.commentpop @@ -2170,22 +2142,23 @@ module_eval(<<'.,.,', 'grammar.ra', 574) end .,., -# reduce 158 omitted +module_eval(<<'.,.,', 'grammar.ra', 530) + def _reduce_158(val, _values, result) + result = aryfy(val[0]) + result + end +.,., -module_eval(<<'.,.,', 'grammar.ra', 586) +module_eval(<<'.,.,', 'grammar.ra', 532) def _reduce_159(val, _values, result) - if val[0].instance_of?(AST::ASTArray) - val[0].push(val[2]) + 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', 595) +module_eval(<<'.,.,', 'grammar.ra', 537) def _reduce_160(val, _values, result) result = ast AST::Selector, :param => val[0], :values => val[2] @@ -2195,7 +2168,7 @@ module_eval(<<'.,.,', 'grammar.ra', 595) # reduce 161 omitted -module_eval(<<'.,.,', 'grammar.ra', 600) +module_eval(<<'.,.,', 'grammar.ra', 542) def _reduce_162(val, _values, result) @lexer.commentpop result = val[1] @@ -2206,7 +2179,7 @@ module_eval(<<'.,.,', 'grammar.ra', 600) # reduce 163 omitted -module_eval(<<'.,.,', 'grammar.ra', 606) +module_eval(<<'.,.,', 'grammar.ra', 548) def _reduce_164(val, _values, result) if val[0].instance_of?(AST::ASTArray) val[0].push(val[2]) @@ -2219,7 +2192,7 @@ module_eval(<<'.,.,', 'grammar.ra', 606) end .,., -module_eval(<<'.,.,', 'grammar.ra', 615) +module_eval(<<'.,.,', 'grammar.ra', 557) def _reduce_165(val, _values, result) result = ast AST::ResourceParam, :param => val[0], :value => val[2] @@ -2241,7 +2214,7 @@ module_eval(<<'.,.,', 'grammar.ra', 615) # reduce 172 omitted -module_eval(<<'.,.,', 'grammar.ra', 626) +module_eval(<<'.,.,', 'grammar.ra', 568) def _reduce_173(val, _values, result) result = ast AST::Default, :value => val[0][:value], :line => val[0][:line] @@ -2251,7 +2224,7 @@ module_eval(<<'.,.,', 'grammar.ra', 626) # reduce 174 omitted -module_eval(<<'.,.,', 'grammar.ra', 631) +module_eval(<<'.,.,', 'grammar.ra', 573) def _reduce_175(val, _values, result) result = [val[0][:value]] result @@ -2260,26 +2233,26 @@ module_eval(<<'.,.,', 'grammar.ra', 631) # reduce 176 omitted -module_eval(<<'.,.,', 'grammar.ra', 633) +module_eval(<<'.,.,', 'grammar.ra', 575) def _reduce_177(val, _values, result) result = val[0] += val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 636) +module_eval(<<'.,.,', 'grammar.ra', 578) def _reduce_178(val, _values, result) val[1].each do |file| import(file) end - result = AST::ASTArray.new(:children => []) + result = nil result end .,., -module_eval(<<'.,.,', 'grammar.ra', 646) +module_eval(<<'.,.,', 'grammar.ra', 588) def _reduce_179(val, _values, result) @lexer.commentpop result = Puppet::Parser::AST::Definition.new(classname(val[1]), @@ -2293,7 +2266,7 @@ module_eval(<<'.,.,', 'grammar.ra', 646) end .,., -module_eval(<<'.,.,', 'grammar.ra', 654) +module_eval(<<'.,.,', 'grammar.ra', 596) def _reduce_180(val, _values, result) @lexer.commentpop result = Puppet::Parser::AST::Definition.new(classname(val[1]), @@ -2304,7 +2277,7 @@ module_eval(<<'.,.,', 'grammar.ra', 654) end .,., -module_eval(<<'.,.,', 'grammar.ra', 662) +module_eval(<<'.,.,', 'grammar.ra', 604) def _reduce_181(val, _values, result) @lexer.commentpop # Our class gets defined in the parent namespace, not our own. @@ -2318,7 +2291,7 @@ module_eval(<<'.,.,', 'grammar.ra', 662) end .,., -module_eval(<<'.,.,', 'grammar.ra', 670) +module_eval(<<'.,.,', 'grammar.ra', 612) def _reduce_182(val, _values, result) @lexer.commentpop # Our class gets defined in the parent namespace, not our own. @@ -2331,7 +2304,7 @@ module_eval(<<'.,.,', 'grammar.ra', 670) end .,., -module_eval(<<'.,.,', 'grammar.ra', 679) +module_eval(<<'.,.,', 'grammar.ra', 621) def _reduce_183(val, _values, result) @lexer.commentpop result = Puppet::Parser::AST::Node.new(val[1], @@ -2342,7 +2315,7 @@ module_eval(<<'.,.,', 'grammar.ra', 679) end .,., -module_eval(<<'.,.,', 'grammar.ra', 684) +module_eval(<<'.,.,', 'grammar.ra', 626) def _reduce_184(val, _values, result) @lexer.commentpop result = Puppet::Parser::AST::Node.new(val[1], ast_context(true).merge(:parent => val[2], :line => val[0][:line])) @@ -2351,35 +2324,35 @@ module_eval(<<'.,.,', 'grammar.ra', 684) end .,., -module_eval(<<'.,.,', 'grammar.ra', 688) +module_eval(<<'.,.,', 'grammar.ra', 630) def _reduce_185(val, _values, result) result = val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 690) +module_eval(<<'.,.,', 'grammar.ra', 632) def _reduce_186(val, _values, result) result = val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 691) +module_eval(<<'.,.,', 'grammar.ra', 633) def _reduce_187(val, _values, result) result = val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 692) +module_eval(<<'.,.,', 'grammar.ra', 634) def _reduce_188(val, _values, result) result = "class" result end .,., -module_eval(<<'.,.,', 'grammar.ra', 697) +module_eval(<<'.,.,', 'grammar.ra', 639) def _reduce_189(val, _values, result) result = [result] @@ -2387,7 +2360,7 @@ module_eval(<<'.,.,', 'grammar.ra', 697) end .,., -module_eval(<<'.,.,', 'grammar.ra', 700) +module_eval(<<'.,.,', 'grammar.ra', 642) def _reduce_190(val, _values, result) result = val[0] result << val[2] @@ -2396,7 +2369,7 @@ module_eval(<<'.,.,', 'grammar.ra', 700) end .,., -module_eval(<<'.,.,', 'grammar.ra', 705) +module_eval(<<'.,.,', 'grammar.ra', 647) def _reduce_191(val, _values, result) result = ast AST::HostName, :value => val[0] @@ -2404,21 +2377,21 @@ module_eval(<<'.,.,', 'grammar.ra', 705) end .,., -module_eval(<<'.,.,', 'grammar.ra', 708) +module_eval(<<'.,.,', 'grammar.ra', 650) def _reduce_192(val, _values, result) result = val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 709) +module_eval(<<'.,.,', 'grammar.ra', 651) def _reduce_193(val, _values, result) result = val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 710) +module_eval(<<'.,.,', 'grammar.ra', 652) def _reduce_194(val, _values, result) result = val[0][:value] result @@ -2427,7 +2400,7 @@ module_eval(<<'.,.,', 'grammar.ra', 710) # reduce 195 omitted -module_eval(<<'.,.,', 'grammar.ra', 714) +module_eval(<<'.,.,', 'grammar.ra', 656) def _reduce_196(val, _values, result) result = nil @@ -2435,7 +2408,7 @@ module_eval(<<'.,.,', 'grammar.ra', 714) end .,., -module_eval(<<'.,.,', 'grammar.ra', 718) +module_eval(<<'.,.,', 'grammar.ra', 660) def _reduce_197(val, _values, result) result = ast AST::ASTArray, :children => [] @@ -2445,7 +2418,7 @@ module_eval(<<'.,.,', 'grammar.ra', 718) # reduce 198 omitted -module_eval(<<'.,.,', 'grammar.ra', 723) +module_eval(<<'.,.,', 'grammar.ra', 665) def _reduce_199(val, _values, result) result = nil @@ -2453,7 +2426,7 @@ module_eval(<<'.,.,', 'grammar.ra', 723) end .,., -module_eval(<<'.,.,', 'grammar.ra', 726) +module_eval(<<'.,.,', 'grammar.ra', 668) def _reduce_200(val, _values, result) result = val[1] result = [result] unless result[0].is_a?(Array) @@ -2464,7 +2437,7 @@ module_eval(<<'.,.,', 'grammar.ra', 726) # reduce 201 omitted -module_eval(<<'.,.,', 'grammar.ra', 732) +module_eval(<<'.,.,', 'grammar.ra', 674) def _reduce_202(val, _values, result) result = val[0] result = [result] unless result[0].is_a?(Array) @@ -2474,7 +2447,7 @@ module_eval(<<'.,.,', 'grammar.ra', 732) end .,., -module_eval(<<'.,.,', 'grammar.ra', 738) +module_eval(<<'.,.,', 'grammar.ra', 680) def _reduce_203(val, _values, result) Puppet.warning addcontext("Deprecation notice: must now include '$' in prototype") result = [val[0][:value], val[2]] @@ -2483,7 +2456,7 @@ module_eval(<<'.,.,', 'grammar.ra', 738) end .,., -module_eval(<<'.,.,', 'grammar.ra', 742) +module_eval(<<'.,.,', 'grammar.ra', 684) def _reduce_204(val, _values, result) Puppet.warning addcontext("Deprecation notice: must now include '$' in prototype") result = [val[0][:value]] @@ -2492,7 +2465,7 @@ module_eval(<<'.,.,', 'grammar.ra', 742) end .,., -module_eval(<<'.,.,', 'grammar.ra', 745) +module_eval(<<'.,.,', 'grammar.ra', 687) def _reduce_205(val, _values, result) result = [val[0][:value], val[2]] @@ -2500,7 +2473,7 @@ module_eval(<<'.,.,', 'grammar.ra', 745) end .,., -module_eval(<<'.,.,', 'grammar.ra', 747) +module_eval(<<'.,.,', 'grammar.ra', 689) def _reduce_206(val, _values, result) result = [val[0][:value]] @@ -2510,7 +2483,7 @@ module_eval(<<'.,.,', 'grammar.ra', 747) # reduce 207 omitted -module_eval(<<'.,.,', 'grammar.ra', 752) +module_eval(<<'.,.,', 'grammar.ra', 694) def _reduce_208(val, _values, result) result = val[1] @@ -2520,7 +2493,7 @@ module_eval(<<'.,.,', 'grammar.ra', 752) # reduce 209 omitted -module_eval(<<'.,.,', 'grammar.ra', 757) +module_eval(<<'.,.,', 'grammar.ra', 699) def _reduce_210(val, _values, result) result = val[1] @@ -2532,7 +2505,7 @@ module_eval(<<'.,.,', 'grammar.ra', 757) # reduce 212 omitted -module_eval(<<'.,.,', 'grammar.ra', 763) +module_eval(<<'.,.,', 'grammar.ra', 705) def _reduce_213(val, _values, result) result = ast AST::Variable, :value => val[0][:value], :line => val[0][:line] @@ -2540,34 +2513,23 @@ module_eval(<<'.,.,', 'grammar.ra', 763) end .,., -module_eval(<<'.,.,', 'grammar.ra', 767) +module_eval(<<'.,.,', 'grammar.ra', 708) def _reduce_214(val, _values, result) - if val[1].instance_of?(AST::ASTArray) - result = val[1] - else - result = ast AST::ASTArray, :children => [val[1]] - end - + result = val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 774) +module_eval(<<'.,.,', 'grammar.ra', 709) def _reduce_215(val, _values, result) - if val[1].instance_of?(AST::ASTArray) - result = val[1] - else - result = ast AST::ASTArray, :children => [val[1]] - end - + result = val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 780) +module_eval(<<'.,.,', 'grammar.ra', 710) def _reduce_216(val, _values, result) - result = ast AST::ASTArray - + result = ast AST::ASTArray result end .,., @@ -2578,14 +2540,14 @@ module_eval(<<'.,.,', 'grammar.ra', 780) # reduce 219 omitted -module_eval(<<'.,.,', 'grammar.ra', 787) +module_eval(<<'.,.,', 'grammar.ra', 716) def _reduce_220(val, _values, result) result = nil result end .,., -module_eval(<<'.,.,', 'grammar.ra', 790) +module_eval(<<'.,.,', 'grammar.ra', 719) def _reduce_221(val, _values, result) result = ast AST::Regex, :value => val[0][:value] @@ -2593,7 +2555,7 @@ module_eval(<<'.,.,', 'grammar.ra', 790) end .,., -module_eval(<<'.,.,', 'grammar.ra', 794) +module_eval(<<'.,.,', 'grammar.ra', 723) def _reduce_222(val, _values, result) if val[1].instance_of?(AST::ASTHash) result = val[1] @@ -2605,7 +2567,7 @@ module_eval(<<'.,.,', 'grammar.ra', 794) end .,., -module_eval(<<'.,.,', 'grammar.ra', 801) +module_eval(<<'.,.,', 'grammar.ra', 730) def _reduce_223(val, _values, result) if val[1].instance_of?(AST::ASTHash) result = val[1] @@ -2617,7 +2579,7 @@ module_eval(<<'.,.,', 'grammar.ra', 801) end .,., -module_eval(<<'.,.,', 'grammar.ra', 807) +module_eval(<<'.,.,', 'grammar.ra', 736) def _reduce_224(val, _values, result) result = ast AST::ASTHash @@ -2627,7 +2589,7 @@ module_eval(<<'.,.,', 'grammar.ra', 807) # reduce 225 omitted -module_eval(<<'.,.,', 'grammar.ra', 812) +module_eval(<<'.,.,', 'grammar.ra', 741) def _reduce_226(val, _values, result) if val[0].instance_of?(AST::ASTHash) result = val[0].merge(val[2]) @@ -2640,7 +2602,7 @@ module_eval(<<'.,.,', 'grammar.ra', 812) end .,., -module_eval(<<'.,.,', 'grammar.ra', 821) +module_eval(<<'.,.,', 'grammar.ra', 750) def _reduce_227(val, _values, result) result = ast AST::ASTHash, { :value => { val[0] => val[2] } } @@ -2648,21 +2610,21 @@ module_eval(<<'.,.,', 'grammar.ra', 821) end .,., -module_eval(<<'.,.,', 'grammar.ra', 824) +module_eval(<<'.,.,', 'grammar.ra', 753) def _reduce_228(val, _values, result) result = val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 825) +module_eval(<<'.,.,', 'grammar.ra', 754) def _reduce_229(val, _values, result) result = val[0] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 828) +module_eval(<<'.,.,', 'grammar.ra', 757) def _reduce_230(val, _values, result) result = ast AST::HashOrArrayAccess, :variable => val[0][:value], :key => val[2] @@ -2672,7 +2634,7 @@ module_eval(<<'.,.,', 'grammar.ra', 828) # reduce 231 omitted -module_eval(<<'.,.,', 'grammar.ra', 833) +module_eval(<<'.,.,', 'grammar.ra', 762) def _reduce_232(val, _values, result) result = ast AST::HashOrArrayAccess, :variable => val[0], :key => val[2] diff --git a/lib/puppet/parser/parser_support.rb b/lib/puppet/parser/parser_support.rb index 859897a16..1c4947891 100644 --- a/lib/puppet/parser/parser_support.rb +++ b/lib/puppet/parser/parser_support.rb @@ -29,18 +29,9 @@ class Puppet::Parser::Parser 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 - - result + # Create an AST array containing a single element + def aryfy(arg) + ast AST::ASTArray, :children => [arg] end # Create an AST object, and automatically add the file and line information if -- cgit From 25048ecc40db746f7e88bb6c5e1fc4f2c0150a4f Mon Sep 17 00:00:00 2001 From: Paul Berry Date: Wed, 1 Sep 2010 14:18:41 -0700 Subject: [#4685] Classes, defines, and nodes allowed inside of non-evaluated conditionals Previously, ASTArray#evaluate() was responsible for checking whether the user had tried to declare a class, define, or node in a prohibited location (such as a conditional construct). This meant that errors would only be reported to the user if the conditional code was actually evaluated. Moved the checking into the parser, so that errors are always reported. --- lib/puppet/parser/ast/astarray.rb | 20 +- lib/puppet/parser/grammar.ra | 25 +- lib/puppet/parser/parser.rb | 2233 ++++++++++++++++++------------------- 3 files changed, 1118 insertions(+), 1160 deletions(-) (limited to 'lib') diff --git a/lib/puppet/parser/ast/astarray.rb b/lib/puppet/parser/ast/astarray.rb index 432300c7a..e856570f8 100644 --- a/lib/puppet/parser/ast/astarray.rb +++ b/lib/puppet/parser/ast/astarray.rb @@ -9,11 +9,6 @@ class Puppet::Parser::AST class ASTArray < Branch include Enumerable - # True if this ASTArray represents a list of statements in a - # context that defines a namespace. Classes and definitions may - # only appear in such a context. - attr_accessor :is_a_namespace - # Return a child by index. Probably never used. def [](index) @children[index] @@ -37,17 +32,10 @@ class Puppet::Parser::AST } rets = items.flatten.collect { |child| - if child.respond_to? :instantiate - if is_a_namespace - # no problem, just don't evaluate it. - else - msg = "Classes, definitions, and nodes may only appear at toplevel or inside other classes" - error = Puppet::Error.new(msg) - error.line = child.line - error.file = child.file - raise error - end - else + # Skip things that respond to :instantiate (classes, nodes, + # and definitions), because they have already been + # instantiated. + if !child.respond_to?(:instantiate) child.safeevaluate(scope) end } diff --git a/lib/puppet/parser/grammar.ra b/lib/puppet/parser/grammar.ra index 3185c435d..9377c0b02 100644 --- a/lib/puppet/parser/grammar.ra +++ b/lib/puppet/parser/grammar.ra @@ -28,22 +28,30 @@ prechigh preclow rule -program: statements { - val[0].is_a_namespace = true - result = val[0] -} +program: statements_and_declarations | nil - statements: statement { + statements_and_declarations: statement_or_declaration { result = ast AST::ASTArray, :children => [val[0]] } - | statements statement { + | statements_and_declarations statement_or_declaration { val[0].push(val[1]) 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" + end + end + result = val[0] +} + # The main list of valid statements -statement: resource +statement_or_declaration: resource | virtualresource | collection | assignment @@ -659,11 +667,10 @@ definition: DEFINE classname argumentlist LBRACE statements RBRACE { } #hostclass: CLASS NAME argumentlist parent LBRACE statements RBRACE { -hostclass: CLASS classname argumentlist classparent 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 - val[5].is_a_namespace = true 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])) diff --git a/lib/puppet/parser/parser.rb b/lib/puppet/parser/parser.rb index e4f5149b9..868716e0d 100644 --- a/lib/puppet/parser/parser.rb +++ b/lib/puppet/parser/parser.rb @@ -21,7 +21,7 @@ module Puppet module Parser class Parser < Racc::Parser -module_eval(<<'...end grammar.ra/module_eval...', 'grammar.ra', 851) +module_eval(<<'...end grammar.ra/module_eval...', 'grammar.ra', 858) # It got too annoying having code in a file that needs to be compiled. require 'puppet/parser/parser_support' @@ -36,651 +36,608 @@ require 'puppet/parser/parser_support' ##### State transition tables begin ### racc_action_table = [ - 256, 257, 228, 82, 54, 72, 75, 181, 251, 48, - 72, 75, 194, 205, 210, 163, 156, 348, 46, 47, - 344, 184, 201, 203, 206, 209, 162, 352, 54, 182, - 351, 169, 54, -168, 72, 75, 241, 242, 102, 305, - 106, 158, 58, 193, 230, 60, 204, 208, 193, 306, - 213, 196, 197, 198, 200, 202, 97, 207, 211, 72, - 75, 72, 75, 163, 199, 59, 58, 71, 245, 60, - 58, 83, 86, 60, 162, 92, 244, 72, 75, 169, - 78, 100, 352, 269, 89, 351, 63, 94, 64, 59, - 228, 326, 71, 59, 162, 59, 83, 86, 83, 268, - 92, 65, 92, 184, 76, 78, 307, 137, 163, 89, - 162, 89, 72, 75, 83, 268, 241, 242, 92, 162, - 59, 163, 59, 137, 169, 62, 254, 89, 207, 211, - 72, 75, 162, 308, 102, 199, 106, 169, 59, 255, - 213, 196, 197, 198, -166, 162, 309, 207, 211, 83, - 268, 310, 97, 92, 199, 72, 75, 355, 137, 102, - -170, 106, 89, 71, 218, 356, 173, 83, 86, 220, - 313, 92, -171, 59, 72, 75, 78, 100, 37, 218, - 89, 249, 38, 94, 220, 246, 247, 173, 71, 11, - 210, 59, 83, 86, 246, 367, 92, 271, 201, 37, - -167, 78, 37, 38, 270, 89, 38, 71, 246, 247, - 11, 83, 86, 11, 14, 92, 59, 72, 75, 76, - 78, 102, 278, 106, 89, 277, 213, 196, 197, 198, - 200, 202, 275, 207, 211, 59, 246, 274, 152, 97, - 199, 37, 318, 72, 75, 127, 319, 102, -169, 106, - 71, 63, 11, 14, 83, 86, -167, 37, 92, 207, - 211, 127, -169, 78, 100, 97, 199, 89, 11, 14, - 94, -166, 117, 72, 75, -185, 71, 82, 59, 336, - 83, 86, 197, 198, 92, 231, 338, 207, 211, 78, - 100, 181, 48, 89, 199, 74, 94, 240, -168, 72, - 75, 241, 242, 102, 59, 106, 71, 184, 176, 37, - 83, 86, 59, 38, 92, 345, 322, 175, 76, 78, - 11, 97, -172, 89, -171, 72, 75, -170, 59, 102, - 214, 106, 71, 64, 59, 215, 83, 86, 173, 217, - 92, -23, -23, -23, -23, 78, 100, 97, 155, 89, - 72, 75, 94, 122, 102, 152, 106, 82, 71, 223, - 59, 122, 83, 86, 72, 75, 92, -168, 102, 225, - 106, 78, 100, -166, 276, 89, 226, 117, 94, 44, - 45, 41, 42, 71, -169, -167, 59, 83, 86, 72, - 75, 92, 226, 102, 229, 106, 78, 71, 52, -168, - 89, 83, 86, 72, 75, 92, -166, 102, -169, 106, - 78, 59, 197, 198, 89, -167, -171, 207, 211, 365, - 231, 152, 71, 234, 199, 59, 83, 86, 50, 210, - 92, -21, -21, -21, -21, 78, 71, 201, 372, 89, - 83, 86, 49, 374, 92, 72, 75, 228, -220, 78, - 59, 226, 354, 89, 377, 72, 75, 40, 39, 102, - 237, 106, 341, nil, 59, 213, 196, 197, 198, 200, - 202, nil, 207, 211, nil, nil, nil, 97, 162, 199, - nil, nil, 83, 268, nil, nil, 92, nil, 71, nil, - nil, 137, 83, 86, nil, 89, 92, 44, 45, 41, - 42, 78, 100, 72, 75, 89, 59, 102, 94, 106, - 213, 196, 197, 198, 200, 202, 59, 207, 211, nil, - 213, 196, 197, 198, 199, 97, nil, 207, 211, 72, - 75, nil, nil, 102, 199, 106, 71, nil, nil, nil, - 83, 86, nil, nil, 92, nil, nil, nil, nil, 78, - 100, 97, nil, 89, nil, nil, 94, nil, nil, 72, - 75, nil, 71, 102, 59, 106, 83, 86, nil, nil, - 92, nil, nil, nil, nil, 78, 100, nil, nil, 89, - nil, 97, 94, nil, nil, 72, 75, nil, nil, 102, - 59, 106, 71, nil, nil, nil, 83, 86, nil, nil, - 92, nil, nil, nil, nil, 78, 100, 97, nil, 89, - 72, 75, 94, nil, 102, nil, 106, nil, 71, nil, - 59, nil, 83, 86, 72, 75, 92, nil, 102, nil, - nil, 78, 100, nil, nil, 89, nil, nil, 94, nil, - nil, nil, nil, 71, nil, nil, 59, 83, 86, 72, - 75, 92, nil, 102, nil, 106, 78, 71, nil, nil, - 89, 83, 143, nil, nil, 92, nil, nil, nil, nil, - 137, 59, nil, nil, 89, 72, 75, nil, nil, 102, - nil, 106, 71, nil, nil, 59, 83, 86, nil, nil, - 92, nil, nil, nil, nil, 78, nil, 97, nil, 89, - nil, 72, 75, nil, nil, 102, nil, 106, 71, nil, - 59, nil, 83, 86, nil, nil, 92, nil, nil, nil, - nil, 78, 100, 97, nil, 89, nil, nil, 94, nil, - nil, 72, 75, nil, 71, 102, 59, 106, 83, 86, - nil, nil, 92, nil, nil, nil, nil, 78, 100, nil, - nil, 89, nil, 97, 94, nil, nil, 72, 75, nil, - nil, 102, 59, 106, 71, nil, nil, nil, 83, 86, - nil, nil, 92, nil, nil, nil, nil, 78, 100, 97, - nil, 89, 72, 75, 94, nil, 102, nil, 106, nil, - 71, nil, 59, nil, 83, 86, nil, nil, 92, nil, - nil, nil, nil, 78, 100, nil, nil, 89, 72, 75, - 94, nil, 102, nil, 106, 71, nil, nil, 59, 83, - 86, nil, nil, 92, nil, nil, nil, nil, 78, nil, - 97, nil, 89, nil, 72, 75, nil, nil, 102, nil, - 106, 71, nil, 59, nil, 83, 86, nil, nil, 92, - nil, nil, 72, 75, 78, 100, 97, nil, 89, 72, - 75, 94, nil, 102, nil, 106, nil, 71, nil, 59, - nil, 83, 86, nil, nil, 92, nil, nil, nil, nil, - 78, 100, nil, nil, 89, 162, nil, 94, nil, 83, - 268, nil, 71, 92, nil, 59, 83, 86, 137, nil, - 92, nil, 89, nil, nil, 78, 72, 75, nil, 89, - 102, nil, 106, 59, nil, nil, nil, nil, nil, nil, - 59, nil, nil, nil, nil, 72, 75, nil, 97, nil, - nil, nil, nil, nil, nil, nil, nil, nil, nil, 71, - nil, nil, nil, 83, 86, nil, nil, 92, 177, nil, - 72, 75, 78, 100, nil, nil, 89, nil, 71, 94, - nil, nil, 83, 86, nil, nil, 92, 59, 72, 75, - 76, 78, 102, 339, 106, 89, nil, nil, nil, nil, - nil, nil, nil, 71, nil, nil, 59, 83, 86, nil, - 97, 92, nil, 72, 75, 76, 78, 102, nil, 106, - 89, 71, nil, 72, 75, 83, 86, nil, nil, 92, - nil, 59, nil, nil, 78, 100, nil, nil, 89, 72, - 75, 94, nil, nil, nil, nil, 71, nil, nil, 59, - 83, 86, nil, nil, 92, nil, 162, nil, nil, 78, - 83, 268, nil, 89, 92, nil, 72, 75, nil, 137, - 102, nil, 162, 89, 59, nil, 83, 268, nil, nil, - 92, nil, 72, 75, 59, 137, 102, nil, 106, 89, - nil, nil, 72, 75, nil, nil, 102, nil, 106, 71, - 59, nil, nil, 83, 268, nil, nil, 92, nil, nil, - nil, nil, 137, nil, 97, 71, 89, nil, nil, 83, - 86, nil, nil, 92, nil, 71, nil, 59, 78, 83, - 86, nil, 89, 92, nil, nil, nil, nil, 78, 100, - 72, 75, 89, 59, 102, 94, 106, 213, 196, 197, - 198, 200, 202, 59, 207, 211, nil, nil, nil, 72, - 75, 199, 97, 102, 189, 106, 72, 75, nil, nil, - 102, nil, 106, 71, nil, nil, nil, 83, 86, nil, - nil, 92, nil, nil, nil, nil, 78, 100, 72, 75, - 89, nil, 71, 94, nil, nil, 83, 86, nil, 71, - 92, 59, nil, 83, 86, 78, nil, 92, nil, 89, - nil, nil, 78, 72, 75, nil, 89, 102, nil, 106, - 59, 162, nil, nil, nil, 83, 268, 59, nil, 92, - nil, 72, 75, nil, 137, 102, nil, 106, 89, nil, - nil, nil, nil, nil, nil, nil, 71, nil, nil, 59, - 83, 86, nil, 97, 92, nil, nil, nil, nil, 78, - nil, 72, 75, 89, 71, 102, nil, 106, 83, 86, - nil, nil, 92, nil, 59, nil, nil, 78, 100, nil, - nil, 89, nil, 97, 94, nil, nil, 72, 75, nil, - nil, 102, 59, 106, 71, nil, nil, nil, 83, 86, - nil, nil, 92, nil, nil, nil, nil, 78, 100, 97, - nil, 89, nil, nil, 94, nil, nil, nil, nil, nil, - 71, nil, 59, nil, 83, 86, 212, nil, 92, nil, - nil, nil, nil, 78, 100, 205, 210, 89, nil, nil, - 94, nil, nil, nil, 201, 203, 206, 209, 59, nil, - 205, 210, nil, nil, nil, nil, nil, nil, nil, 201, - 203, 206, 209, nil, nil, nil, nil, nil, 204, 208, - nil, nil, 213, 196, 197, 198, 200, 202, nil, 207, - 211, nil, nil, 204, 208, nil, 199, 213, 196, 197, - 198, 200, 202, nil, 207, 211, 205, 210, nil, nil, - nil, 199, nil, nil, nil, 201, 203, 206, 209, nil, - nil, 205, 210, nil, nil, nil, nil, nil, nil, nil, - 201, 203, 206, 209, nil, nil, nil, nil, nil, 204, - 208, nil, nil, 213, 196, 197, 198, 200, 202, nil, - 207, 211, nil, nil, 204, 208, nil, 199, 213, 196, - 197, 198, 200, 202, nil, 207, 211, 205, 210, nil, - nil, nil, 199, nil, nil, nil, 201, 203, 206, 209, - nil, nil, 205, 210, nil, nil, nil, nil, nil, nil, - 273, 201, 203, 206, 209, nil, nil, nil, nil, nil, - nil, 208, nil, nil, 213, 196, 197, 198, 200, 202, - nil, 207, 211, nil, nil, 204, 208, nil, 199, 213, - 196, 197, 198, 200, 202, nil, 207, 211, 205, 210, - nil, nil, nil, 199, nil, nil, nil, 201, 203, 206, - 209, nil, nil, 26, 210, 33, 1, nil, 7, 12, - nil, 17, 201, 23, nil, 29, nil, 3, nil, nil, - 11, 14, nil, 210, nil, 213, 196, 197, 198, 200, - 202, 201, 207, 211, nil, nil, nil, nil, nil, 199, - 213, 196, 197, 198, 200, 202, nil, 207, 211, nil, - nil, 324, nil, nil, 199, nil, nil, nil, nil, 213, - 196, 197, 198, 200, 202, nil, 207, 211, nil, nil, - 379, nil, 26, 199, 33, 1, nil, 7, 12, nil, - 17, nil, 23, nil, 29, nil, 3, nil, nil, 11, - 14, 26, 382, 33, 1, nil, 7, 12, nil, 17, - nil, 23, nil, 29, nil, 3, nil, nil, 11, 14, - nil, 296, nil, 26, nil, 33, 1, nil, 7, 12, - nil, 17, nil, 23, nil, 29, nil, 3, nil, nil, - 11, 14, 26, 364, 33, 1, nil, 7, 12, nil, - 17, nil, 23, nil, 29, nil, 3, nil, nil, 11, - 14, nil, 381, nil, 26, nil, 33, 1, nil, 7, - 12, nil, 17, nil, 23, nil, 29, nil, 3, nil, - nil, 11, 14, 26, 383, 33, 1, nil, 7, 12, - nil, 17, nil, 23, nil, 29, nil, 3, nil, nil, - 11, 14, nil, 357, nil, 26, nil, 33, 1, nil, - 7, 12, nil, 17, nil, 23, nil, 29, nil, 3, - nil, nil, 11, 14, 26, 363, 33, 1, nil, 7, - 12, nil, 17, nil, 23, nil, 29, nil, 3, nil, - nil, 11, 14, nil, 375, nil, 26, nil, 33, 1, - nil, 7, 12, nil, 17, nil, 23, nil, 29, nil, - 3, nil, nil, 11, 14, 26, 304, 33, 1, nil, - 7, 12, nil, 17, nil, 23, nil, 29, nil, 3, - nil, nil, 11, 14, nil, 349, nil, 26, nil, 33, - 1, nil, 7, 12, nil, 17, nil, 23, nil, 29, - nil, 3, nil, nil, 11, 14, 26, nil, 33, 1, - nil, 7, 12, nil, 17, nil, 23, nil, 29, nil, - 3, nil, nil, 11, 14, 26, nil, 33, 1, nil, - 7, 12, nil, 17, nil, 23, nil, 29, nil, 3, - nil, nil, 11, 14 ] + 242, 243, 55, 231, 356, 112, 157, 113, 78, 298, + 68, 71, 357, 181, 186, 326, 344, 340, 55, 295, + 114, 231, 177, 179, 182, 185, 170, 294, 68, 71, + 286, 158, 100, 285, 103, 68, 71, 291, 292, 55, + 59, 291, 292, 61, 111, 233, 180, 184, 198, 231, + 189, 172, 173, 174, 176, 178, 59, 183, 187, 61, + -168, 66, 170, 60, 175, 79, 81, 186, 202, 88, + 112, 166, 79, 252, 74, 177, 88, 59, 84, 60, + 61, 139, 68, 71, 333, 84, 100, 117, 103, 60, + 36, -170, 68, 71, 38, 306, 60, 307, 203, 240, + 60, 10, 203, 189, 172, 173, 174, 176, 178, 202, + 183, 187, 241, 202, 209, 66, 218, 175, 209, 79, + 81, 219, 284, 88, 309, 202, 256, 283, 74, 79, + 252, 308, 84, 88, 203, 68, 71, 310, 139, 100, + 203, 103, 84, 60, 218, 202, 256, 367, 36, 219, + 209, 202, 38, 60, 68, 71, 209, 95, 100, 10, + 103, 68, 71, 68, 71, 100, 337, 103, 66, 335, + 199, 154, 79, 81, 173, 174, 88, 183, 187, 183, + 187, 74, 99, 95, 175, 84, 175, 66, 90, 311, + 337, 79, 81, 335, 66, 88, 60, 287, 79, 81, + 74, 198, 88, 315, 84, 68, 71, 74, 99, -172, + 213, 84, 68, 71, 90, 60, 100, 36, 103, 68, + 71, 38, 60, 100, 318, 103, 68, 71, 10, 15, + 36, -167, 213, 355, 38, 167, 36, 313, 202, 154, + 127, 10, 79, 252, 323, 66, 88, 10, 15, 79, + 81, 139, 66, 88, 166, 84, 79, 81, 74, 202, + 88, 229, 84, 79, 252, 74, 60, 88, 49, 84, + 68, 71, 139, 60, 78, -186, 84, 47, 48, 49, + 60, 329, 36, 170, 183, 187, 127, 60, -169, 68, + 71, 175, 70, 10, 15, 68, 71, 161, -171, 100, + 289, 103, -169, 66, 291, 292, 60, 79, 81, 258, + -167, 88, -170, 256, 257, 72, 74, 95, -168, 60, + 84, 156, 66, 154, 68, 71, 79, 81, 66, 122, + 88, 60, 79, 81, 72, 74, 88, -170, -173, 84, + -172, 74, 99, 68, 71, 84, -171, 100, 90, 103, + 60, 200, 334, 68, 71, 213, 60, 202, 215, 254, + 338, 79, 252, 173, 174, 88, 122, 296, 183, 187, + 139, 256, 257, 216, 84, 175, 66, 234, 68, 71, + 79, 81, 113, 117, 88, 60, 202, 217, 78, 74, + 79, 252, 353, 84, 88, 53, 68, 71, 223, 139, + 100, 260, 103, 84, 60, 43, 44, 40, 41, 358, + 52, 66, 51, 225, 60, 79, 81, -169, 229, 88, + 365, 68, 71, 72, 74, 100, 238, 103, 84, 66, + 228, -167, 234, 79, 81, 372, 373, 88, -169, 60, + -167, -170, 74, 95, -168, -172, 84, 68, 71, 45, + 375, 100, 229, 103, 66, -221, 232, 60, 79, 81, + 378, 39, 88, -24, -24, -24, -24, 74, 99, 95, + -168, 84, 383, 384, 90, nil, nil, 68, 71, nil, + 66, 100, 60, 103, 79, 81, nil, nil, 88, -22, + -22, -22, -22, 74, 99, nil, nil, 84, nil, 95, + 90, nil, nil, 68, 71, nil, nil, 100, 60, 103, + 66, nil, nil, nil, 79, 81, nil, nil, 88, 43, + 44, 40, 41, 74, 99, 95, nil, 84, nil, nil, + 90, nil, nil, 68, 71, nil, 66, 100, 60, 103, + 79, 81, nil, nil, 88, nil, nil, nil, nil, 74, + 99, nil, nil, 84, nil, 95, 90, nil, nil, 68, + 71, nil, nil, 100, 60, 103, 66, nil, nil, nil, + 79, 81, nil, nil, 88, nil, nil, 68, 71, 74, + 99, 100, nil, 84, 68, 71, 90, nil, 100, nil, + 103, nil, 66, nil, 60, nil, 79, 81, nil, nil, + 88, nil, nil, nil, nil, 74, 95, nil, nil, 84, + 66, nil, nil, nil, 79, 144, nil, 66, 88, nil, + 60, 79, 81, 139, nil, 88, nil, 84, nil, nil, + 74, 99, nil, nil, 84, 68, 71, 90, 60, 100, + nil, 103, nil, nil, nil, 60, nil, nil, nil, nil, + nil, nil, nil, nil, 68, 71, nil, 95, 100, nil, + 103, 68, 71, nil, nil, 100, nil, 103, 66, nil, + nil, nil, 79, 81, nil, nil, 88, nil, nil, 68, + 71, 74, 99, nil, nil, 84, nil, 66, 90, nil, + nil, 79, 81, nil, 66, 88, 60, nil, 79, 81, + 74, nil, 88, nil, 84, 68, 71, 74, nil, nil, + nil, 84, 202, nil, nil, 60, 79, 252, nil, nil, + 88, nil, 60, nil, nil, 139, 68, 71, 162, 84, + 100, nil, 103, nil, nil, nil, nil, nil, 66, nil, + 60, nil, 79, 81, nil, nil, 88, nil, 95, nil, + 72, 74, 68, 71, nil, 84, 100, nil, 103, 66, + nil, nil, nil, 79, 81, nil, 60, 88, nil, nil, + nil, nil, 74, 99, 95, nil, 84, 68, 71, 90, + nil, nil, nil, nil, nil, 66, nil, 60, nil, 79, + 81, nil, nil, 88, nil, nil, nil, nil, 74, 99, + 327, nil, 84, 68, 71, 90, nil, 100, nil, 103, + 66, nil, nil, 60, 79, 81, nil, nil, 88, nil, + nil, nil, 72, 74, nil, 95, nil, 84, 68, 71, + nil, nil, 100, nil, 103, nil, 66, nil, 60, nil, + 79, 81, 68, 71, 88, nil, 100, nil, 103, 74, + 99, nil, nil, 84, nil, nil, 90, nil, nil, nil, + nil, 66, nil, nil, 60, 79, 81, 68, 71, 88, + nil, 100, nil, 103, 74, 66, nil, nil, 84, 79, + 81, 68, 71, 88, nil, 100, nil, nil, 74, 60, + nil, nil, 84, nil, nil, nil, nil, nil, nil, nil, + 66, nil, nil, 60, 79, 81, nil, nil, 88, nil, + nil, 68, 71, 74, 66, nil, nil, 84, 79, 252, + nil, nil, 88, nil, nil, nil, nil, 139, 60, 68, + 71, 84, nil, 100, nil, 103, nil, nil, nil, nil, + nil, nil, 60, nil, 202, nil, nil, nil, 79, 252, + nil, 95, 88, nil, nil, nil, nil, 139, nil, 68, + 71, 84, 66, 100, nil, 103, 79, 81, nil, nil, + 88, nil, 60, nil, nil, 74, 99, nil, nil, 84, + nil, 95, 90, nil, nil, 68, 71, nil, nil, 100, + 60, 103, 66, nil, nil, nil, 79, 81, nil, nil, + 88, nil, nil, nil, nil, 74, 99, 95, nil, 84, + nil, nil, 90, nil, nil, 68, 71, nil, 66, 100, + 60, 103, 79, 81, nil, nil, 88, nil, nil, nil, + nil, 74, 99, nil, nil, 84, nil, 95, 90, nil, + nil, 68, 71, nil, nil, 100, 60, 103, 66, nil, + nil, nil, 79, 81, nil, nil, 88, nil, nil, nil, + nil, 74, 99, 95, nil, 84, nil, nil, 90, nil, + nil, 68, 71, nil, 66, 100, 60, 103, 79, 81, + nil, nil, 88, nil, nil, nil, nil, 74, 99, nil, + nil, 84, nil, 95, 90, nil, nil, 68, 71, nil, + nil, 100, 60, 103, 66, nil, nil, nil, 79, 81, + nil, nil, 88, nil, nil, nil, nil, 74, 99, 95, + nil, 84, nil, nil, 90, nil, nil, 68, 71, nil, + 66, 100, 60, 103, 79, 81, nil, nil, 88, nil, + nil, nil, nil, 74, 99, nil, nil, 84, nil, 95, + 90, nil, nil, 68, 71, nil, nil, 100, 60, 103, + 66, nil, nil, nil, 79, 81, nil, nil, 88, nil, + nil, nil, nil, 74, 99, 95, nil, 84, 68, 71, + 90, nil, 100, 193, 103, nil, 66, nil, 60, nil, + 79, 81, nil, nil, 88, nil, nil, nil, nil, 74, + 99, nil, nil, 84, 68, 71, 90, nil, 100, nil, + 103, 66, nil, nil, 60, 79, 81, nil, nil, 88, + nil, nil, nil, nil, 74, nil, 95, nil, 84, nil, + 68, 71, nil, nil, 100, nil, 103, 66, nil, 60, + nil, 79, 81, nil, nil, 88, nil, nil, nil, nil, + 74, 99, 95, nil, 84, nil, nil, 90, nil, nil, + nil, nil, nil, 66, nil, 60, nil, 79, 81, 188, + nil, 88, nil, nil, nil, nil, 74, 99, 181, 186, + 84, nil, nil, 90, nil, nil, nil, 177, 179, 182, + 185, 60, nil, 181, 186, nil, nil, nil, nil, nil, + nil, 282, 177, 179, 182, 185, nil, nil, nil, nil, + nil, 180, 184, nil, nil, 189, 172, 173, 174, 176, + 178, nil, 183, 187, nil, nil, 180, 184, nil, 175, + 189, 172, 173, 174, 176, 178, nil, 183, 187, 181, + 186, nil, nil, nil, 175, nil, nil, nil, 177, 179, + 182, 185, nil, nil, 181, 186, nil, nil, nil, nil, + nil, nil, nil, 177, 179, 182, 185, nil, nil, nil, + nil, nil, nil, nil, nil, nil, 189, 172, 173, 174, + 176, 178, nil, 183, 187, nil, nil, 180, 184, nil, + 175, 189, 172, 173, 174, 176, 178, nil, 183, 187, + 181, 186, nil, nil, nil, 175, nil, nil, nil, 177, + 179, 182, 185, nil, nil, 181, 186, nil, nil, nil, + nil, nil, nil, nil, 177, 179, 182, 185, nil, nil, + nil, nil, nil, 180, 184, nil, nil, 189, 172, 173, + 174, 176, 178, nil, 183, 187, nil, nil, nil, 184, + nil, 175, 189, 172, 173, 174, 176, 178, nil, 183, + 187, 181, 186, nil, nil, nil, 175, nil, nil, nil, + 177, 179, 182, 185, nil, nil, nil, 186, nil, 189, + 172, 173, 174, 176, 178, 177, 183, 187, nil, nil, + nil, nil, nil, 175, 180, 184, 186, nil, 189, 172, + 173, 174, 176, 178, 177, 183, 187, nil, nil, nil, + nil, 186, 175, 189, 172, 173, 174, 176, 178, 177, + 183, 187, nil, nil, nil, nil, nil, 175, nil, nil, + nil, nil, 189, 172, 173, 174, 176, 178, nil, 183, + 187, 280, nil, nil, nil, nil, 175, 189, 172, 173, + 174, 176, 178, nil, 183, 187, nil, nil, nil, nil, + 325, 175, 26, nil, 32, 1, nil, 8, 11, nil, + 18, nil, 23, nil, 29, nil, 2, nil, nil, 10, + 15, 26, 363, 32, 1, nil, 8, 11, nil, 18, + nil, 23, nil, 29, nil, 2, nil, nil, 10, 15, + nil, 382, nil, 26, nil, 32, 1, nil, 8, 11, + nil, 18, nil, 23, nil, 29, nil, 2, nil, nil, + 10, 15, 26, 380, 32, 1, nil, 8, 11, nil, + 18, nil, 23, nil, 29, nil, 2, nil, nil, 10, + 15, nil, 376, nil, 26, nil, 32, 1, nil, 8, + 11, nil, 18, nil, 23, nil, 29, nil, 2, nil, + nil, 10, 15, 26, 305, 32, 1, nil, 8, 11, + nil, 18, nil, 23, nil, 29, nil, 2, nil, nil, + 10, 15, nil, nil, nil, 26, nil, 32, 1, nil, + 8, 11, nil, 18, nil, 23, nil, 29, nil, 2, + nil, nil, 10, 15, 26, nil, 32, 1, nil, 8, + 11, nil, 18, nil, 23, nil, 29, nil, 2, nil, + nil, 10, 15, 26, nil, 32, 1, nil, 8, 11, + nil, 18, nil, 23, nil, 29, nil, 2, nil, nil, + 10, 15, 26, nil, 32, 1, nil, 8, 11, nil, + 18, nil, 23, nil, 29, nil, 2, nil, nil, 10, + 15, 189, 172, 173, 174, 176, 178, nil, 183, 187, + 189, 172, 173, 174, nil, 175, nil, 183, 187, 189, + 172, 173, 174, nil, 175, nil, 183, 187, nil, nil, + nil, nil, nil, 175 ] racc_action_check = [ - 180, 180, 152, 86, 156, 106, 106, 272, 174, 7, - 277, 277, 106, 180, 180, 65, 55, 277, 7, 7, - 272, 86, 180, 180, 180, 180, 65, 296, 17, 80, - 296, 65, 158, 95, 202, 202, 174, 174, 202, 218, - 202, 55, 156, 106, 152, 156, 180, 180, 277, 219, - 180, 180, 180, 180, 180, 180, 202, 180, 180, 181, - 181, 368, 368, 239, 180, 156, 17, 202, 165, 17, - 158, 202, 202, 158, 239, 202, 165, 182, 182, 239, - 202, 202, 349, 182, 202, 349, 22, 202, 22, 17, - 143, 243, 181, 158, 368, 202, 181, 181, 368, 368, - 181, 22, 368, 143, 181, 181, 220, 368, 163, 181, - 182, 368, 355, 355, 182, 182, 243, 243, 182, 163, - 181, 62, 368, 182, 163, 22, 178, 182, 281, 281, - 351, 351, 62, 221, 351, 281, 351, 62, 182, 178, - 285, 285, 285, 285, 101, 355, 221, 285, 285, 355, - 355, 224, 351, 355, 285, 341, 341, 300, 355, 341, - 91, 341, 355, 351, 308, 300, 226, 351, 351, 308, - 227, 351, 90, 355, 184, 184, 351, 351, 12, 122, - 351, 171, 12, 351, 122, 171, 171, 229, 341, 12, - 286, 351, 341, 341, 343, 343, 341, 184, 286, 1, - 87, 341, 30, 1, 183, 341, 30, 184, 183, 183, - 1, 184, 184, 30, 30, 184, 341, 196, 196, 184, - 184, 196, 195, 196, 184, 195, 286, 286, 286, 286, - 286, 286, 188, 286, 286, 184, 188, 188, 231, 196, - 286, 120, 232, 197, 197, 120, 233, 197, 103, 197, - 196, 85, 120, 120, 196, 196, 105, 43, 196, 280, - 280, 43, 84, 196, 196, 197, 280, 196, 43, 43, - 196, 81, 215, 23, 23, 78, 197, 23, 196, 250, - 197, 197, 279, 279, 197, 252, 253, 279, 279, 197, - 197, 77, 71, 197, 279, 23, 197, 160, 68, 26, - 26, 160, 160, 26, 197, 26, 23, 268, 67, 234, - 23, 23, 211, 234, 23, 274, 234, 66, 23, 23, - 234, 26, 107, 23, 108, 198, 198, 109, 207, 198, - 114, 198, 26, 115, 23, 119, 26, 26, 64, 121, - 26, 35, 35, 35, 35, 26, 26, 198, 52, 26, - 29, 29, 26, 51, 29, 50, 29, 127, 198, 132, - 26, 36, 198, 198, 307, 307, 198, 133, 307, 136, - 307, 198, 198, 138, 192, 198, 139, 33, 198, 34, - 34, 34, 34, 29, 140, 142, 198, 29, 29, 305, - 305, 29, 315, 305, 144, 305, 29, 307, 16, 327, - 29, 307, 307, 199, 199, 307, 328, 199, 330, 199, - 307, 29, 297, 297, 307, 331, 332, 297, 297, 337, - 153, 175, 305, 154, 297, 307, 305, 305, 9, 288, - 305, 28, 28, 28, 28, 305, 199, 288, 352, 305, - 199, 199, 8, 356, 199, 298, 298, 173, 367, 199, - 305, 172, 298, 199, 369, 200, 200, 3, 2, 200, - 157, 200, 263, nil, 199, 288, 288, 288, 288, 288, - 288, nil, 288, 288, nil, nil, nil, 200, 298, 288, - nil, nil, 298, 298, nil, nil, 298, nil, 200, nil, - nil, 298, 200, 200, nil, 298, 200, 4, 4, 4, - 4, 200, 200, 39, 39, 200, 298, 39, 200, 39, - 293, 293, 293, 293, 293, 293, 200, 293, 293, nil, - 283, 283, 283, 283, 293, 39, nil, 283, 283, 201, - 201, nil, nil, 201, 283, 201, 39, nil, nil, nil, - 39, 39, nil, nil, 39, nil, nil, nil, nil, 39, - 39, 201, nil, 39, nil, nil, 39, nil, nil, 46, - 46, nil, 201, 46, 39, 46, 201, 201, nil, nil, - 201, nil, nil, nil, nil, 201, 201, nil, nil, 201, - nil, 46, 201, nil, nil, 47, 47, nil, nil, 47, - 201, 47, 46, nil, nil, nil, 46, 46, nil, nil, - 46, nil, nil, nil, nil, 46, 46, 47, nil, 46, - 48, 48, 46, nil, 48, nil, 48, nil, 47, nil, - 46, nil, 47, 47, 49, 49, 47, nil, 49, nil, - nil, 47, 47, nil, nil, 47, nil, nil, 47, nil, - nil, nil, nil, 48, nil, nil, 47, 48, 48, 176, - 176, 48, nil, 176, nil, 176, 48, 49, nil, nil, - 48, 49, 49, nil, nil, 49, nil, nil, nil, nil, - 49, 48, nil, nil, 49, 203, 203, nil, nil, 203, - nil, 203, 176, nil, nil, 49, 176, 176, nil, nil, - 176, nil, nil, nil, nil, 176, nil, 203, nil, 176, - nil, 204, 204, nil, nil, 204, nil, 204, 203, nil, - 176, nil, 203, 203, nil, nil, 203, nil, nil, nil, - nil, 203, 203, 204, nil, 203, nil, nil, 203, nil, - nil, 205, 205, nil, 204, 205, 203, 205, 204, 204, - nil, nil, 204, nil, nil, nil, nil, 204, 204, nil, - nil, 204, nil, 205, 204, nil, nil, 100, 100, nil, - nil, 100, 204, 100, 205, nil, nil, nil, 205, 205, - nil, nil, 205, nil, nil, nil, nil, 205, 205, 100, - nil, 205, 63, 63, 205, nil, 63, nil, 63, nil, - 100, nil, 205, nil, 100, 100, nil, nil, 100, nil, - nil, nil, nil, 100, 100, nil, nil, 100, 208, 208, - 100, nil, 208, nil, 208, 63, nil, nil, 100, 63, - 63, nil, nil, 63, nil, nil, nil, nil, 63, nil, - 208, nil, 63, nil, 209, 209, nil, nil, 209, nil, - 209, 208, nil, 63, nil, 208, 208, nil, nil, 208, - nil, nil, 269, 269, 208, 208, 209, nil, 208, 276, - 276, 208, nil, 276, nil, 276, nil, 209, nil, 208, - nil, 209, 209, nil, nil, 209, nil, nil, nil, nil, - 209, 209, nil, nil, 209, 269, nil, 209, nil, 269, - 269, nil, 276, 269, nil, 209, 276, 276, 269, nil, - 276, nil, 269, nil, nil, 276, 256, 256, nil, 276, - 256, nil, 256, 269, nil, nil, nil, nil, nil, nil, - 276, nil, nil, nil, nil, 74, 74, nil, 256, nil, - nil, nil, nil, nil, nil, nil, nil, nil, nil, 256, - nil, nil, nil, 256, 256, nil, nil, 256, 74, nil, - 254, 254, 256, 256, nil, nil, 256, nil, 74, 256, - nil, nil, 74, 74, nil, nil, 74, 256, 75, 75, - 74, 74, 75, 254, 75, 74, nil, nil, nil, nil, - nil, nil, nil, 254, nil, nil, 74, 254, 254, nil, - 75, 254, nil, 248, 248, 254, 254, 248, nil, 248, - 254, 75, nil, 245, 245, 75, 75, nil, nil, 75, - nil, 254, nil, nil, 75, 75, nil, nil, 75, 244, - 244, 75, nil, nil, nil, nil, 248, nil, nil, 75, - 248, 248, nil, nil, 248, nil, 245, nil, nil, 248, - 245, 245, nil, 248, 245, nil, 225, 225, nil, 245, - 225, nil, 244, 245, 248, nil, 244, 244, nil, nil, - 244, nil, 82, 82, 245, 244, 82, nil, 82, 244, - nil, nil, 210, 210, nil, nil, 210, nil, 210, 225, - 244, nil, nil, 225, 225, nil, nil, 225, nil, nil, - nil, nil, 225, nil, 210, 82, 225, nil, nil, 82, - 82, nil, nil, 82, nil, 210, nil, 225, 82, 210, - 210, nil, 82, 210, nil, nil, nil, nil, 210, 210, - 213, 213, 210, 82, 213, 210, 213, 284, 284, 284, - 284, 284, 284, 210, 284, 284, nil, nil, nil, 102, - 102, 284, 213, 102, 102, 102, 230, 230, nil, nil, - 230, nil, 230, 213, nil, nil, nil, 213, 213, nil, - nil, 213, nil, nil, nil, nil, 213, 213, 214, 214, - 213, nil, 102, 213, nil, nil, 102, 102, nil, 230, - 102, 213, nil, 230, 230, 102, nil, 230, nil, 102, - nil, nil, 230, 228, 228, nil, 230, 228, nil, 228, - 102, 214, nil, nil, nil, 214, 214, 230, nil, 214, - nil, 94, 94, nil, 214, 94, nil, 94, 214, nil, - nil, nil, nil, nil, nil, nil, 228, nil, nil, 214, - 228, 228, nil, 94, 228, nil, nil, nil, nil, 228, - nil, 97, 97, 228, 94, 97, nil, 97, 94, 94, - nil, nil, 94, nil, 228, nil, nil, 94, 94, nil, - nil, 94, nil, 97, 94, nil, nil, 206, 206, nil, - nil, 206, 94, 206, 97, nil, nil, nil, 97, 97, - nil, nil, 97, nil, nil, nil, nil, 97, 97, 206, - nil, 97, nil, nil, 97, nil, nil, nil, nil, nil, - 206, nil, 97, nil, 206, 206, 111, nil, 206, nil, - nil, nil, nil, 206, 206, 111, 111, 206, nil, nil, - 206, nil, nil, nil, 111, 111, 111, 111, 206, nil, - 124, 124, nil, nil, nil, nil, nil, nil, nil, 124, - 124, 124, 124, nil, nil, nil, nil, nil, 111, 111, - nil, nil, 111, 111, 111, 111, 111, 111, nil, 111, - 111, nil, nil, 124, 124, nil, 111, 124, 124, 124, - 124, 124, 124, nil, 124, 124, 130, 130, nil, nil, - nil, 124, nil, nil, nil, 130, 130, 130, 130, nil, - nil, 131, 131, nil, nil, nil, nil, nil, nil, nil, - 131, 131, 131, 131, nil, nil, nil, nil, nil, 130, - 130, nil, nil, 130, 130, 130, 130, 130, 130, nil, - 130, 130, nil, nil, 131, 131, nil, 130, 131, 131, - 131, 131, 131, 131, nil, 131, 131, 287, 287, nil, - nil, nil, 131, nil, nil, nil, 287, 287, 287, 287, - nil, nil, 186, 186, nil, nil, nil, nil, nil, nil, - 186, 186, 186, 186, 186, nil, nil, nil, nil, nil, - nil, 287, nil, nil, 287, 287, 287, 287, 287, 287, - nil, 287, 287, nil, nil, 186, 186, nil, 287, 186, - 186, 186, 186, 186, 186, nil, 186, 186, 291, 291, - nil, nil, nil, 186, nil, nil, nil, 291, 291, 291, - 291, nil, nil, 19, 292, 19, 19, nil, 19, 19, - nil, 19, 292, 19, nil, 19, nil, 19, nil, nil, - 19, 19, nil, 289, nil, 291, 291, 291, 291, 291, - 291, 289, 291, 291, nil, nil, nil, nil, nil, 291, - 292, 292, 292, 292, 292, 292, nil, 292, 292, nil, - nil, 237, nil, nil, 292, nil, nil, nil, nil, 289, - 289, 289, 289, 289, 289, nil, 289, 289, nil, nil, - 372, nil, 237, 289, 237, 237, nil, 237, 237, nil, - 237, nil, 237, nil, 237, nil, 237, nil, nil, 237, - 237, 372, 378, 372, 372, nil, 372, 372, nil, 372, - nil, 372, nil, 372, nil, 372, nil, nil, 372, 372, - nil, 212, nil, 378, nil, 378, 378, nil, 378, 378, - nil, 378, nil, 378, nil, 378, nil, 378, nil, nil, - 378, 378, 212, 323, 212, 212, nil, 212, 212, nil, - 212, nil, 212, nil, 212, nil, 212, nil, nil, 212, - 212, nil, 374, nil, 323, nil, 323, 323, nil, 323, - 323, nil, 323, nil, 323, nil, 323, nil, 323, nil, - nil, 323, 323, 374, 380, 374, 374, nil, 374, 374, - nil, 374, nil, 374, nil, 374, nil, 374, nil, nil, - 374, 374, nil, 303, nil, 380, nil, 380, 380, nil, - 380, 380, nil, 380, nil, 380, nil, 380, nil, 380, - nil, nil, 380, 380, 303, 319, 303, 303, nil, 303, - 303, nil, 303, nil, 303, nil, 303, nil, 303, nil, - nil, 303, 303, nil, 362, nil, 319, nil, 319, 319, - nil, 319, 319, nil, 319, nil, 319, nil, 319, nil, - 319, nil, nil, 319, 319, 362, 217, 362, 362, nil, - 362, 362, nil, 362, nil, 362, nil, 362, nil, 362, - nil, nil, 362, 362, nil, 295, nil, 217, nil, 217, - 217, nil, 217, 217, nil, 217, nil, 217, nil, 217, - nil, 217, nil, nil, 217, 217, 295, nil, 295, 295, - nil, 295, 295, nil, 295, nil, 295, nil, 295, nil, - 295, nil, nil, 295, 295, 0, nil, 0, 0, nil, - 0, 0, nil, 0, nil, 0, nil, 0, nil, 0, - nil, nil, 0, 0 ] + 164, 164, 158, 154, 301, 27, 56, 27, 81, 214, + 285, 285, 301, 164, 164, 239, 293, 285, 18, 206, + 27, 213, 164, 164, 164, 164, 81, 206, 175, 175, + 194, 56, 175, 194, 175, 368, 368, 214, 214, 157, + 158, 293, 293, 158, 27, 154, 164, 164, 285, 144, + 164, 164, 164, 164, 164, 164, 18, 164, 164, 18, + 85, 175, 144, 158, 164, 175, 175, 272, 368, 175, + 83, 261, 368, 368, 175, 272, 368, 157, 175, 18, + 157, 368, 161, 161, 261, 368, 161, 216, 161, 175, + 1, 82, 356, 356, 1, 218, 368, 219, 203, 163, + 157, 1, 114, 272, 272, 272, 272, 272, 272, 203, + 272, 272, 163, 114, 203, 161, 122, 272, 114, 161, + 161, 122, 192, 161, 221, 356, 192, 192, 161, 356, + 356, 220, 161, 356, 290, 335, 335, 221, 356, 335, + 111, 335, 356, 161, 309, 290, 331, 331, 11, 309, + 290, 111, 11, 356, 329, 329, 111, 335, 329, 11, + 329, 48, 48, 103, 103, 48, 334, 48, 335, 334, + 103, 200, 335, 335, 262, 262, 335, 263, 263, 262, + 262, 335, 335, 48, 263, 335, 262, 329, 335, 224, + 280, 329, 329, 280, 48, 329, 335, 197, 48, 48, + 329, 103, 48, 227, 329, 295, 295, 48, 48, 87, + 229, 48, 307, 307, 48, 329, 307, 33, 307, 306, + 306, 33, 48, 306, 230, 306, 299, 299, 33, 33, + 225, 80, 232, 299, 225, 77, 46, 225, 295, 234, + 46, 225, 295, 295, 235, 307, 295, 46, 46, 307, + 307, 295, 306, 307, 75, 295, 306, 306, 307, 299, + 306, 212, 307, 299, 299, 306, 295, 299, 8, 306, + 23, 23, 299, 307, 23, 74, 299, 8, 8, 66, + 306, 249, 42, 252, 264, 264, 42, 299, 65, 166, + 166, 264, 23, 42, 42, 26, 26, 64, 89, 26, + 201, 26, 94, 23, 201, 201, 187, 23, 23, 169, + 101, 23, 102, 169, 169, 23, 23, 26, 105, 183, + 23, 53, 166, 52, 294, 294, 166, 166, 26, 50, + 166, 23, 26, 26, 166, 166, 26, 143, 106, 166, + 107, 26, 26, 29, 29, 26, 108, 29, 26, 29, + 166, 110, 279, 167, 167, 113, 26, 294, 115, 167, + 283, 294, 294, 281, 281, 294, 37, 211, 281, 281, + 294, 211, 211, 116, 294, 281, 29, 288, 170, 170, + 29, 29, 119, 32, 29, 294, 167, 121, 127, 29, + 167, 167, 297, 29, 167, 17, 287, 287, 133, 167, + 287, 170, 287, 167, 29, 3, 3, 3, 3, 304, + 13, 170, 12, 134, 167, 170, 170, 136, 320, 170, + 324, 172, 172, 170, 170, 172, 159, 172, 170, 287, + 140, 141, 155, 287, 287, 337, 342, 287, 346, 170, + 347, 349, 287, 172, 350, 351, 287, 45, 45, 5, + 357, 45, 142, 45, 172, 367, 147, 287, 172, 172, + 369, 2, 172, 4, 4, 4, 4, 172, 172, 45, + 146, 172, 379, 381, 172, nil, nil, 173, 173, nil, + 45, 173, 172, 173, 45, 45, nil, nil, 45, 31, + 31, 31, 31, 45, 45, nil, nil, 45, nil, 173, + 45, nil, nil, 47, 47, nil, nil, 47, 45, 47, + 173, nil, nil, nil, 173, 173, nil, nil, 173, 6, + 6, 6, 6, 173, 173, 47, nil, 173, nil, nil, + 173, nil, nil, 174, 174, nil, 47, 174, 173, 174, + 47, 47, nil, nil, 47, nil, nil, nil, nil, 47, + 47, nil, nil, 47, nil, 174, 47, nil, nil, 49, + 49, nil, nil, 49, 47, 49, 174, nil, nil, nil, + 174, 174, nil, nil, 174, nil, nil, 51, 51, 174, + 174, 51, nil, 174, 176, 176, 174, nil, 176, nil, + 176, nil, 49, nil, 174, nil, 49, 49, nil, nil, + 49, nil, nil, nil, nil, 49, 176, nil, nil, 49, + 51, nil, nil, nil, 51, 51, nil, 176, 51, nil, + 49, 176, 176, 51, nil, 176, nil, 51, nil, nil, + 176, 176, nil, nil, 176, 177, 177, 176, 51, 177, + nil, 177, nil, nil, nil, 176, nil, nil, nil, nil, + nil, nil, nil, nil, 112, 112, nil, 177, 112, nil, + 112, 259, 259, nil, nil, 259, nil, 259, 177, nil, + nil, nil, 177, 177, nil, nil, 177, nil, nil, 254, + 254, 177, 177, nil, nil, 177, nil, 112, 177, nil, + nil, 112, 112, nil, 259, 112, 177, nil, 259, 259, + 112, nil, 259, nil, 112, 70, 70, 259, nil, nil, + nil, 259, 254, nil, nil, 112, 254, 254, nil, nil, + 254, nil, 259, nil, nil, 254, 242, 242, 70, 254, + 242, nil, 242, nil, nil, nil, nil, nil, 70, nil, + 254, nil, 70, 70, nil, nil, 70, nil, 242, nil, + 70, 70, 71, 71, nil, 70, 71, nil, 71, 242, + nil, nil, nil, 242, 242, nil, 70, 242, nil, nil, + nil, nil, 242, 242, 71, nil, 242, 240, 240, 242, + nil, nil, nil, nil, nil, 71, nil, 242, nil, 71, + 71, nil, nil, 71, nil, nil, nil, nil, 71, 71, + 240, nil, 71, 178, 178, 71, nil, 178, nil, 178, + 240, nil, nil, 71, 240, 240, nil, nil, 240, nil, + nil, nil, 240, 240, nil, 178, nil, 240, 233, 233, + nil, nil, 233, nil, 233, nil, 178, nil, 240, nil, + 178, 178, 78, 78, 178, nil, 78, nil, 78, 178, + 178, nil, nil, 178, nil, nil, 178, nil, nil, nil, + nil, 233, nil, nil, 178, 233, 233, 231, 231, 233, + nil, 231, nil, 231, 233, 78, nil, nil, 233, 78, + 78, 228, 228, 78, nil, 228, nil, nil, 78, 233, + nil, nil, 78, nil, nil, nil, nil, nil, nil, nil, + 231, nil, nil, 78, 231, 231, nil, nil, 231, nil, + nil, 215, 215, 231, 228, nil, nil, 231, 228, 228, + nil, nil, 228, nil, nil, nil, nil, 228, 231, 179, + 179, 228, nil, 179, nil, 179, nil, nil, nil, nil, + nil, nil, 228, nil, 215, nil, nil, nil, 215, 215, + nil, 179, 215, nil, nil, nil, nil, 215, nil, 185, + 185, 215, 179, 185, nil, 185, 179, 179, nil, nil, + 179, nil, 215, nil, nil, 179, 179, nil, nil, 179, + nil, 185, 179, nil, nil, 181, 181, nil, nil, 181, + 179, 181, 185, nil, nil, nil, 185, 185, nil, nil, + 185, nil, nil, nil, nil, 185, 185, 181, nil, 185, + nil, nil, 185, nil, nil, 189, 189, nil, 181, 189, + 185, 189, 181, 181, nil, nil, 181, nil, nil, nil, + nil, 181, 181, nil, nil, 181, nil, 189, 181, nil, + nil, 90, 90, nil, nil, 90, 181, 90, 189, nil, + nil, nil, 189, 189, nil, nil, 189, nil, nil, nil, + nil, 189, 189, 90, nil, 189, nil, nil, 189, nil, + nil, 182, 182, nil, 90, 182, 189, 182, 90, 90, + nil, nil, 90, nil, nil, nil, nil, 90, 90, nil, + nil, 90, nil, 182, 90, nil, nil, 184, 184, nil, + nil, 184, 90, 184, 182, nil, nil, nil, 182, 182, + nil, nil, 182, nil, nil, nil, nil, 182, 182, 184, + nil, 182, nil, nil, 182, nil, nil, 95, 95, nil, + 184, 95, 182, 95, 184, 184, nil, nil, 184, nil, + nil, nil, nil, 184, 184, nil, nil, 184, nil, 95, + 184, nil, nil, 99, 99, nil, nil, 99, 184, 99, + 95, nil, nil, nil, 95, 95, nil, nil, 95, nil, + nil, nil, nil, 95, 95, 99, nil, 95, 100, 100, + 95, nil, 100, 100, 100, nil, 99, nil, 95, nil, + 99, 99, nil, nil, 99, nil, nil, nil, nil, 99, + 99, nil, nil, 99, 186, 186, 99, nil, 186, nil, + 186, 100, nil, nil, 99, 100, 100, nil, nil, 100, + nil, nil, nil, nil, 100, nil, 186, nil, 100, nil, + 180, 180, nil, nil, 180, nil, 180, 186, nil, 100, + nil, 186, 186, nil, nil, 186, nil, nil, nil, nil, + 186, 186, 180, nil, 186, nil, nil, 186, nil, nil, + nil, nil, nil, 180, nil, 186, nil, 180, 180, 91, + nil, 180, nil, nil, nil, nil, 180, 180, 91, 91, + 180, nil, nil, 180, nil, nil, nil, 91, 91, 91, + 91, 180, nil, 190, 190, nil, nil, nil, nil, nil, + nil, 190, 190, 190, 190, 190, nil, nil, nil, nil, + nil, 91, 91, nil, nil, 91, 91, 91, 91, 91, + 91, nil, 91, 91, nil, nil, 190, 190, nil, 91, + 190, 190, 190, 190, 190, 190, nil, 190, 190, 274, + 274, nil, nil, nil, 190, nil, nil, nil, 274, 274, + 274, 274, nil, nil, 132, 132, nil, nil, nil, nil, + nil, nil, nil, 132, 132, 132, 132, nil, nil, nil, + nil, nil, nil, nil, nil, nil, 274, 274, 274, 274, + 274, 274, nil, 274, 274, nil, nil, 132, 132, nil, + 274, 132, 132, 132, 132, 132, 132, nil, 132, 132, + 131, 131, nil, nil, nil, 132, nil, nil, nil, 131, + 131, 131, 131, nil, nil, 270, 270, nil, nil, nil, + nil, nil, nil, nil, 270, 270, 270, 270, nil, nil, + nil, nil, nil, 131, 131, nil, nil, 131, 131, 131, + 131, 131, 131, nil, 131, 131, nil, nil, nil, 270, + nil, 131, 270, 270, 270, 270, 270, 270, nil, 270, + 270, 129, 129, nil, nil, nil, 270, nil, nil, nil, + 129, 129, 129, 129, nil, nil, nil, 269, nil, 276, + 276, 276, 276, 276, 276, 269, 276, 276, nil, nil, + nil, nil, nil, 276, 129, 129, 275, nil, 129, 129, + 129, 129, 129, 129, 275, 129, 129, nil, nil, nil, + nil, 271, 129, 269, 269, 269, 269, 269, 269, 271, + 269, 269, nil, nil, nil, nil, nil, 269, nil, nil, + nil, nil, 275, 275, 275, 275, 275, 275, nil, 275, + 275, 188, nil, nil, nil, nil, 275, 271, 271, 271, + 271, 271, 271, nil, 271, 271, nil, nil, nil, nil, + 238, 271, 188, nil, 188, 188, nil, 188, 188, nil, + 188, nil, 188, nil, 188, nil, 188, nil, nil, 188, + 188, 238, 311, 238, 238, nil, 238, 238, nil, 238, + nil, 238, nil, 238, nil, 238, nil, nil, 238, 238, + nil, 375, nil, 311, nil, 311, 311, nil, 311, 311, + nil, 311, nil, 311, nil, 311, nil, 311, nil, nil, + 311, 311, 375, 372, 375, 375, nil, 375, 375, nil, + 375, nil, 375, nil, 375, nil, 375, nil, nil, 375, + 375, nil, 362, nil, 372, nil, 372, 372, nil, 372, + 372, nil, 372, nil, 372, nil, 372, nil, 372, nil, + nil, 372, 372, 362, 217, 362, 362, nil, 362, 362, + nil, 362, nil, 362, nil, 362, nil, 362, nil, nil, + 362, 362, nil, nil, nil, 217, nil, 217, 217, nil, + 217, 217, nil, 217, nil, 217, nil, 217, nil, 217, + nil, nil, 217, 217, 0, nil, 0, 0, nil, 0, + 0, nil, 0, nil, 0, nil, 0, nil, 0, nil, + nil, 0, 0, 20, nil, 20, 20, nil, 20, 20, + nil, 20, nil, 20, nil, 20, nil, 20, nil, nil, + 20, 20, 278, nil, 278, 278, nil, 278, 278, nil, + 278, nil, 278, nil, 278, nil, 278, nil, nil, 278, + 278, 267, 267, 267, 267, 267, 267, nil, 267, 267, + 266, 266, 266, 266, nil, 267, nil, 266, 266, 268, + 268, 268, 268, nil, 266, nil, 268, 268, nil, nil, + nil, nil, nil, 268 ] racc_action_pointer = [ - 1795, 163, 443, 413, 433, nil, nil, 3, 434, 420, - nil, nil, 142, nil, nil, nil, 398, 26, nil, 1483, - nil, nil, 80, 271, nil, nil, 297, nil, 367, 348, - 166, nil, nil, 375, 315, 277, 337, nil, nil, 501, - nil, nil, nil, 221, nil, nil, 557, 583, 608, 622, - 315, 329, 348, nil, nil, 4, nil, nil, nil, nil, - nil, nil, 97, 780, 298, -9, 309, 302, 275, nil, - nil, 286, nil, nil, 923, 966, nil, 279, 269, nil, - 6, 248, 1060, nil, 239, 245, -3, 177, nil, nil, - 149, 137, nil, nil, 1209, 10, nil, 1239, nil, nil, - 755, 121, 1137, 225, nil, 233, 3, 299, 301, 304, - nil, 1298, nil, nil, 322, 325, nil, nil, nil, 323, - 205, 331, 144, nil, 1313, nil, nil, 351, nil, nil, - 1359, 1374, 352, 344, nil, nil, 328, nil, 350, 364, - 361, nil, 362, 79, 374, nil, nil, nil, nil, nil, - nil, nil, -9, 408, 386, nil, 2, 452, 30, nil, - 251, nil, nil, 84, nil, 50, nil, nil, nil, nil, - nil, 174, 439, 436, -14, 381, 647, nil, 114, nil, - -4, 57, 75, 197, 172, nil, 1435, nil, 225, nil, - nil, nil, 363, nil, nil, 213, 215, 241, 323, 401, - 453, 527, 32, 673, 699, 729, 1265, 265, 806, 832, - 1070, 249, 1612, 1118, 1166, 270, nil, 1757, 24, 24, - 91, 121, nil, nil, 142, 1044, 126, 161, 1191, 147, - 1144, 198, 233, 238, 273, nil, nil, 1552, nil, 39, - nil, nil, nil, 66, 1017, 1001, nil, nil, 991, nil, - 270, nil, 273, 279, 948, nil, 904, nil, nil, nil, - nil, nil, nil, 451, nil, nil, nil, nil, 283, 850, - nil, nil, -5, nil, 308, nil, 857, 8, nil, 226, - 198, 67, nil, 466, 1073, 86, 172, 1420, 411, 1515, - nil, 1481, 1496, 456, nil, 1776, -4, 356, 443, nil, - 145, nil, nil, 1694, nil, 387, nil, 362, 129, nil, - nil, nil, nil, nil, nil, 380, nil, nil, nil, 1716, - nil, nil, nil, 1634, nil, nil, nil, 376, 383, nil, - 385, 392, 393, nil, nil, nil, nil, 410, nil, nil, - nil, 153, nil, 183, nil, nil, nil, nil, nil, 51, - nil, 128, 430, nil, nil, 110, 435, nil, nil, nil, - nil, nil, 1735, nil, nil, nil, nil, 439, 59, 445, - nil, nil, 1571, nil, 1653, nil, nil, nil, 1593, nil, - 1675, nil, nil, nil ] + 1674, 54, 417, 341, 399, 434, 455, nil, 262, nil, + nil, 112, 404, 402, nil, nil, nil, 395, 16, nil, + 1693, nil, nil, 268, nil, nil, 293, -1, nil, 341, + nil, 425, 381, 181, nil, nil, nil, 342, nil, nil, + nil, nil, 246, nil, nil, 445, 200, 501, 159, 557, + 305, 575, 283, 321, nil, nil, -6, nil, nil, nil, + nil, nil, nil, nil, 291, 265, 273, nil, nil, nil, + 703, 750, nil, nil, 269, 242, nil, 212, 840, nil, + 208, 2, 68, 64, nil, 37, nil, 186, nil, 275, + 1039, 1261, nil, nil, 279, 1125, nil, nil, nil, 1151, + 1176, 287, 289, 161, nil, 295, 315, 317, 323, nil, + 343, 116, 652, 315, 78, 350, 361, nil, nil, 374, + nil, 379, 81, nil, nil, nil, nil, 382, nil, 1444, + nil, 1383, 1337, 391, 376, nil, 394, nil, nil, nil, + 389, 408, 440, 314, 38, nil, 447, 436, nil, nil, + nil, nil, nil, nil, -8, 420, nil, 37, 0, 418, + nil, 80, nil, 87, -4, nil, 287, 351, nil, 302, + 376, nil, 419, 475, 531, 26, 582, 633, 801, 927, + 1228, 983, 1069, 256, 1095, 957, 1202, 243, 1532, 1013, + 1276, nil, 115, nil, 21, nil, nil, 186, nil, nil, + 131, 254, nil, 74, nil, nil, 1, nil, nil, nil, + nil, 360, 249, 10, -13, 909, 85, 1655, 80, 82, + 106, 112, nil, nil, 181, 194, nil, 194, 879, 170, + 215, 865, 192, 826, 199, 235, nil, nil, 1551, 8, + 775, nil, 724, nil, nil, nil, nil, nil, nil, 270, + nil, nil, 259, nil, 677, nil, nil, nil, nil, 659, + nil, 59, 118, 116, 223, nil, 1716, 1707, 1725, 1459, + 1398, 1493, 49, nil, 1322, 1478, 1425, nil, 1712, 343, + 159, 307, nil, 353, nil, 8, nil, 394, 365, nil, + 110, nil, nil, -9, 322, 203, nil, 383, nil, 224, + nil, -8, nil, nil, 400, nil, 217, 210, nil, 109, + nil, 1573, nil, nil, nil, nil, nil, nil, nil, nil, + 406, nil, nil, nil, 411, nil, nil, nil, nil, 152, + nil, 135, nil, nil, 135, 133, nil, 427, nil, nil, + nil, nil, 427, nil, nil, nil, 415, 417, nil, 418, + 421, 422, nil, nil, nil, nil, 90, 442, nil, nil, + nil, nil, 1633, nil, nil, nil, nil, 446, 33, 451, + nil, nil, 1614, nil, nil, 1592, nil, nil, nil, 463, + nil, 464, nil, nil, nil ] racc_action_default = [ - -196, -233, -233, -50, -233, -8, -9, -233, -233, -22, - -10, -187, -188, -11, -185, -12, -233, -233, -13, -1, - -14, -2, -233, -186, -15, -3, -233, -16, -5, -233, - -233, -17, -6, -233, -18, -7, -196, -188, -186, -233, - -51, -26, -27, -233, -24, -25, -233, -233, -233, -85, - -92, -196, -233, -195, -193, -196, -189, -191, -192, -221, - -194, -4, -196, -233, -85, -196, -53, -231, -42, -174, - -43, -213, -117, -33, -233, -233, -44, -31, -74, -32, - -233, -36, -233, -122, -37, -233, -73, -38, -172, -72, - -39, -40, -173, -41, -233, -103, -111, -233, -132, -112, - -233, -104, -233, -108, -110, -105, -233, -114, -106, -113, - -109, -233, -125, -107, -233, -233, -49, -175, -176, -178, - -233, -233, -197, -198, -83, -19, -22, -186, -21, -23, - -82, -84, -233, -75, -86, -81, -70, -74, -76, -219, - -79, -68, -77, -73, -233, -171, -170, -80, -78, -90, - -91, -93, -233, -219, -196, 384, -233, -233, -233, -207, - -233, -57, -213, -196, -59, -233, -66, -65, -56, -73, - -95, -233, -219, -233, -233, -92, -233, -30, -233, -118, - -233, -233, -233, -233, -233, -142, -233, -149, -233, -216, - -229, -225, -233, -228, -224, -233, -233, -233, -233, -233, - -233, -233, -233, -233, -233, -233, -233, -233, -233, -233, - -233, -233, -233, -233, -233, -233, -20, -233, -206, -233, - -204, -233, -201, -230, -233, -71, -220, -233, -233, -85, - -233, -220, -233, -233, -233, -209, -190, -233, -208, -233, - -54, -62, -61, -233, -233, -233, -217, -218, -233, -124, - -233, -55, -219, -233, -233, -28, -233, -120, -119, -35, - -34, -168, -166, -233, -169, -160, -167, -161, -73, -233, - -123, -116, -233, -152, -218, -214, -233, -233, -222, -137, - -139, -138, -133, -140, -144, -141, -146, -151, -148, -145, - -134, -150, -147, -143, -135, -233, -128, -136, -233, -154, - -233, -158, -177, -233, -180, -233, -199, -233, -233, -200, - -45, -69, -87, -46, -88, -219, -89, -94, -48, -233, - -211, -210, -212, -233, -184, -58, -60, -97, -98, -63, - -102, -99, -100, -101, -64, -96, -47, -233, -232, -29, - -121, -233, -163, -219, -115, -215, -227, -226, -223, -128, - -127, -233, -233, -155, -153, -233, -233, -179, -205, -203, - -202, -67, -233, -182, -183, -52, -165, -218, -233, -233, - -126, -129, -233, -159, -233, -181, -164, -162, -233, -131, - -233, -157, -130, -156 ] + -197, -234, -51, -19, -8, -234, -234, -9, -234, -10, + -188, -189, -234, -23, -11, -186, -12, -234, -234, -13, + -1, -14, -2, -187, -15, -3, -234, -234, -16, -234, + -17, -6, -234, -234, -18, -7, -189, -197, -187, -52, + -27, -28, -234, -25, -26, -234, -234, -234, -234, -234, + -197, -86, -93, -234, -196, -194, -197, -190, -192, -193, + -222, -195, -4, -42, -232, -43, -214, -175, -118, -44, + -234, -234, -45, -34, -75, -32, -33, -234, -234, -123, + -37, -74, -38, -234, -73, -39, -173, -40, -174, -41, + -234, -234, -126, -108, -104, -234, -112, -133, -113, -234, + -234, -105, -109, -234, -111, -106, -115, -107, -114, -110, + -54, -197, -234, -86, -197, -234, -179, -176, -177, -234, + -50, -234, -198, -199, -24, -21, -23, -187, -22, -84, + -20, -83, -85, -234, -197, -79, -76, -87, -82, -75, + -71, -77, -220, -80, -74, -69, -78, -234, -172, -171, + -81, -91, -92, -94, -234, -220, 385, -234, -234, -234, + -208, -234, -31, -234, -234, -119, -234, -234, -96, -234, + -234, -143, -234, -234, -234, -234, -234, -234, -234, -234, + -234, -234, -234, -234, -234, -234, -234, -234, -234, -234, + -234, -150, -234, -217, -234, -230, -226, -234, -229, -225, + -93, -234, -214, -197, -58, -60, -234, -67, -57, -74, + -66, -234, -220, -234, -234, -234, -234, -234, -207, -205, + -234, -234, -202, -231, -234, -234, -210, -234, -72, -221, + -234, -234, -86, -234, -221, -234, -191, -209, -234, -234, + -234, -29, -234, -121, -120, -36, -35, -169, -167, -234, + -170, -161, -74, -168, -234, -162, -218, -219, -124, -234, + -117, -234, -138, -140, -139, -134, -141, -145, -142, -147, + -152, -149, -146, -135, -151, -148, -144, -136, -5, -234, + -129, -137, -153, -219, -215, -234, -223, -234, -220, -55, + -234, -63, -62, -234, -234, -234, -125, -234, -56, -234, + -155, -234, -159, -178, -234, -181, -234, -234, -200, -234, + -201, -234, -212, -213, -211, -46, -70, -88, -47, -89, + -220, -90, -95, -49, -234, -185, -233, -30, -122, -234, + -164, -220, -97, -116, -129, -234, -128, -234, -216, -227, + -224, -228, -234, -59, -61, -102, -98, -99, -64, -103, + -100, -101, -65, -48, -156, -154, -234, -234, -180, -206, + -204, -203, -234, -183, -68, -184, -166, -219, -234, -234, + -127, -130, -234, -53, -160, -234, -182, -165, -163, -234, + -132, -234, -158, -131, -157 ] racc_goto_table = [ - 22, 9, 68, 112, 53, 118, 61, 36, 91, 222, - 19, 267, 70, 93, 2, 227, 139, 191, 51, 22, - 9, 179, 77, 56, 73, 149, 21, 141, 133, 232, - 115, 172, 153, 2, 146, 263, 125, 116, 135, 148, - 147, 299, 129, 22, 126, 260, 160, 350, 250, 174, - 128, 171, 43, 68, 121, 329, 334, 298, 368, 91, - 258, 265, 123, 70, 93, 317, 343, 301, 136, 154, - 183, 119, 224, 178, 233, 73, 55, 123, 157, 66, - 238, 159, 120, 219, 221, 190, 325, 321, 195, 16, - 188, nil, nil, nil, nil, nil, nil, nil, 342, nil, - 370, nil, nil, nil, nil, nil, nil, nil, nil, nil, - nil, nil, nil, 216, nil, nil, nil, nil, 260, 129, - 22, 126, 263, nil, nil, 353, nil, 128, 337, nil, - nil, nil, nil, nil, nil, nil, nil, nil, nil, 81, - nil, nil, nil, 53, nil, 53, nil, 243, nil, nil, - 149, 301, nil, nil, nil, nil, nil, 252, nil, nil, - 68, 261, 236, 68, nil, 138, 91, 146, nil, 91, - 70, 93, nil, 70, 93, nil, nil, nil, 166, nil, - 235, 166, 259, 272, nil, 73, nil, 302, 347, nil, - 81, 361, nil, 261, 290, 360, 315, 376, 294, 146, - nil, 312, 340, 311, 133, nil, 149, nil, 373, nil, - 146, nil, 22, 9, 135, 148, 147, 22, 9, 369, - nil, 263, 295, 327, 327, nil, 2, 303, nil, 146, - 146, 2, nil, 68, 333, 333, nil, 22, 9, 91, - 320, 88, nil, 70, 93, nil, nil, 323, 261, nil, - nil, 2, nil, nil, 146, 259, 190, nil, nil, nil, - nil, nil, nil, nil, nil, nil, nil, 88, nil, nil, - nil, nil, nil, nil, nil, 87, nil, 261, nil, 166, - nil, nil, 61, 146, nil, nil, nil, nil, nil, nil, - 61, nil, 88, nil, nil, 22, 9, 81, 262, nil, - 81, 142, nil, 22, 9, nil, nil, nil, nil, 2, - 61, nil, nil, nil, nil, nil, nil, 2, nil, 22, - 9, nil, nil, 22, 9, nil, 87, nil, 371, 362, - 262, nil, nil, 2, 261, nil, nil, 2, nil, nil, - 146, 138, nil, nil, nil, nil, nil, 261, nil, 61, - nil, nil, nil, 146, nil, 166, nil, nil, nil, nil, - 328, 328, 22, 9, 114, 61, nil, 61, nil, 84, - 81, nil, 22, 9, 22, 9, 2, 90, 22, 9, - 22, 9, 378, 132, 380, 262, 2, nil, 2, nil, - nil, nil, 2, nil, 2, 140, nil, nil, 170, 88, - 88, nil, 88, 145, nil, nil, nil, nil, 167, nil, - nil, 167, nil, nil, 262, nil, nil, 170, nil, nil, - 84, nil, nil, nil, nil, nil, nil, nil, 90, nil, - nil, nil, 88, 87, 266, nil, 87, 170, nil, nil, - nil, nil, nil, 88, nil, nil, nil, nil, nil, nil, + 27, 13, 5, 37, 62, 255, 249, 20, 118, 196, + 92, 89, 142, 50, 155, 300, 69, 63, 222, 336, + 27, 13, 5, 165, 73, 75, 57, 279, 348, 352, + 246, 151, 145, 119, 343, 150, 121, 230, 65, 149, + 299, 22, 27, 126, 138, 135, 27, 126, 201, 134, + 235, 214, 120, 87, 302, 86, 304, 244, 89, 42, + 169, 128, 46, 69, 63, 128, 136, 251, 368, 331, + 322, 73, 163, 370, 212, 125, 124, 324, 123, 130, + 124, 148, 192, 86, 116, 65, 140, 224, 56, 159, + 227, 123, 330, 249, 211, 237, 220, 160, 221, 354, + 87, 110, 86, 115, 246, 314, 194, 297, 17, nil, + nil, nil, nil, nil, nil, nil, nil, nil, 195, nil, + nil, nil, nil, 133, nil, nil, nil, nil, nil, nil, + nil, nil, nil, nil, 54, nil, nil, nil, 302, nil, + 293, nil, nil, nil, nil, nil, nil, nil, nil, nil, + nil, nil, 168, nil, 89, 149, nil, nil, 89, 69, + 63, nil, 288, 69, 63, 236, nil, 245, nil, nil, + nil, 73, 261, 82, 168, 226, nil, nil, nil, 151, + nil, 65, 247, 342, nil, 65, 168, nil, 27, 13, + 5, 339, 303, 320, 328, 374, 87, 148, 86, 86, + 87, 143, 86, 149, 80, 361, 377, 249, 317, 316, + nil, 379, 150, 151, 381, 364, 149, 27, 13, 5, + 82, 138, 135, nil, nil, nil, 369, 312, 89, nil, + 247, nil, 141, 69, 63, 239, nil, nil, 27, 13, + 5, 245, 149, 136, nil, 148, nil, 86, nil, 265, + nil, 80, nil, nil, nil, 65, nil, nil, 148, nil, + 86, 210, 62, nil, 210, nil, nil, nil, 85, 247, + 87, nil, 86, 54, 54, nil, nil, nil, 27, 13, + 5, nil, 149, 149, 148, nil, 86, 149, 345, 345, + nil, nil, 207, nil, nil, 207, 146, nil, nil, 273, + 195, nil, nil, 277, nil, 319, nil, 321, nil, 346, + 346, 27, 13, 5, 247, 85, 82, 250, 362, 371, + 82, nil, nil, nil, 351, 351, 86, 86, nil, 148, + nil, 86, nil, 332, nil, nil, nil, nil, nil, nil, + nil, nil, nil, nil, 149, nil, 62, 80, 248, nil, + nil, 80, nil, 210, nil, nil, 149, nil, nil, nil, + nil, 341, 27, 13, 5, 250, nil, nil, nil, nil, + nil, 247, 27, 13, 5, 27, 13, 5, 143, nil, + 359, 360, nil, 247, 207, nil, 148, nil, 86, nil, + 82, nil, 129, nil, 131, 132, 248, nil, 148, nil, + 86, nil, nil, 366, 250, nil, nil, nil, nil, 141, + nil, 85, 253, nil, nil, 85, nil, nil, 164, nil, + nil, 80, nil, nil, nil, nil, nil, nil, nil, nil, + nil, nil, nil, nil, nil, 248, nil, 171, nil, nil, + 210, nil, 190, nil, 349, 349, 191, nil, nil, 250, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, - nil, nil, 88, 88, nil, nil, 266, nil, nil, nil, - nil, 262, 88, nil, nil, nil, nil, 142, nil, nil, - nil, nil, nil, nil, 262, nil, nil, 88, nil, nil, - nil, nil, nil, nil, nil, nil, 331, 331, nil, nil, - nil, nil, nil, nil, nil, nil, 87, nil, nil, 167, - nil, 253, nil, nil, nil, nil, 88, nil, nil, nil, - nil, 266, nil, nil, nil, nil, nil, 84, 264, nil, - 84, nil, nil, nil, 282, 90, 145, nil, 90, nil, + 253, nil, nil, nil, nil, nil, nil, nil, nil, nil, + nil, 207, nil, 146, nil, 347, 347, nil, nil, nil, + 248, nil, nil, nil, nil, 85, nil, nil, nil, nil, + nil, nil, nil, nil, nil, nil, nil, nil, nil, 253, + nil, nil, nil, nil, nil, nil, 250, nil, nil, nil, + nil, nil, nil, nil, nil, nil, nil, nil, 250, 262, + 263, 264, nil, 266, 267, 268, 269, 270, 271, 272, + nil, 274, 275, 276, nil, nil, 281, 248, nil, 350, + 350, nil, nil, nil, 253, nil, nil, nil, nil, 248, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, - 266, nil, nil, nil, nil, nil, nil, nil, nil, nil, - 264, nil, nil, 314, nil, 316, nil, 124, 145, nil, - nil, 140, nil, 88, 130, 131, nil, nil, nil, 145, - nil, nil, nil, 335, nil, 167, 88, nil, nil, nil, - 330, 330, nil, nil, nil, nil, nil, nil, 332, 332, - 84, nil, nil, 180, nil, nil, nil, 266, 90, nil, - nil, 346, nil, nil, nil, 264, nil, nil, nil, nil, - 266, nil, 185, 145, nil, 186, nil, nil, 187, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, - 358, nil, 359, nil, 264, nil, nil, nil, nil, nil, - nil, nil, 145, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, - nil, nil, nil, nil, nil, nil, 366, nil, nil, nil, + nil, nil, nil, nil, nil, nil, nil, nil, nil, 164, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, - nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, - nil, 264, nil, nil, nil, nil, nil, nil, nil, 145, - nil, nil, nil, nil, 264, nil, nil, nil, nil, nil, - nil, nil, 145, nil, 279, 280, 281, nil, 283, 284, - 285, 286, 287, 288, 289, nil, 291, 292, 293, nil, - nil, 297, nil, nil, nil, nil, nil, nil, nil, nil, - nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, - nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, - nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, - nil, nil, nil, nil, 180 ] + nil, 253, nil, nil, nil, nil, nil, nil, nil, nil, + nil, nil, nil, 253 ] racc_goto_check = [ - 37, 21, 30, 62, 64, 72, 4, 32, 28, 82, - 2, 70, 31, 29, 52, 36, 35, 85, 32, 37, - 21, 60, 22, 78, 21, 53, 3, 47, 30, 36, - 37, 35, 38, 52, 28, 68, 19, 5, 31, 29, - 50, 66, 7, 37, 21, 23, 41, 63, 36, 41, - 5, 57, 20, 30, 74, 46, 46, 65, 58, 28, - 61, 69, 3, 31, 29, 56, 71, 68, 33, 74, - 57, 73, 34, 22, 75, 21, 76, 3, 77, 40, - 79, 3, 20, 80, 81, 30, 42, 83, 84, 1, - 57, nil, nil, nil, nil, nil, nil, nil, 70, nil, - 63, nil, nil, nil, nil, nil, nil, nil, nil, nil, - nil, nil, nil, 19, nil, nil, nil, nil, 23, 7, - 37, 21, 68, nil, nil, 66, nil, 5, 36, nil, - nil, nil, nil, nil, nil, nil, nil, nil, nil, 24, - nil, nil, nil, 64, nil, 64, nil, 41, nil, nil, - 53, 68, nil, nil, nil, nil, nil, 38, nil, nil, - 30, 30, 78, 30, nil, 24, 28, 28, nil, 28, - 31, 29, nil, 31, 29, nil, nil, nil, 24, nil, - 3, 24, 21, 22, nil, 21, nil, 72, 85, nil, - 24, 36, nil, 30, 64, 82, 35, 70, 64, 28, - nil, 53, 60, 47, 30, nil, 53, nil, 68, nil, - 28, nil, 37, 21, 31, 29, 50, 37, 21, 36, - nil, 68, 2, 30, 30, nil, 52, 2, nil, 28, - 28, 52, nil, 30, 29, 29, nil, 37, 21, 28, - 32, 49, nil, 31, 29, nil, nil, 2, 30, nil, - nil, 52, nil, nil, 28, 21, 30, nil, nil, nil, - nil, nil, nil, nil, nil, nil, nil, 49, nil, nil, - nil, nil, nil, nil, nil, 26, nil, 30, nil, 24, - nil, nil, 4, 28, nil, nil, nil, nil, nil, nil, - 4, nil, 49, nil, nil, 37, 21, 24, 24, nil, - 24, 26, nil, 37, 21, nil, nil, nil, nil, 52, - 4, nil, nil, nil, nil, nil, nil, 52, nil, 37, - 21, nil, nil, 37, 21, nil, 26, nil, 62, 2, - 24, nil, nil, 52, 30, nil, nil, 52, nil, nil, - 28, 24, nil, nil, nil, nil, nil, 30, nil, 4, - nil, nil, nil, 28, nil, 24, nil, nil, nil, nil, - 24, 24, 37, 21, 54, 4, nil, 4, nil, 25, - 24, nil, 37, 21, 37, 21, 52, 27, 37, 21, - 37, 21, 2, 54, 2, 24, 52, nil, 52, nil, - nil, nil, 52, nil, 52, 25, nil, nil, 54, 49, - 49, nil, 49, 27, nil, nil, nil, nil, 25, nil, - nil, 25, nil, nil, 24, nil, nil, 54, nil, nil, - 25, nil, nil, nil, nil, nil, nil, nil, 27, nil, - nil, nil, 49, 26, 26, nil, 26, 54, nil, nil, - nil, nil, nil, 49, nil, nil, nil, nil, nil, nil, - nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, - nil, nil, 49, 49, nil, nil, 26, nil, nil, nil, - nil, 24, 49, nil, nil, nil, nil, 26, nil, nil, - nil, nil, nil, nil, 24, nil, nil, 49, nil, nil, - nil, nil, nil, nil, nil, nil, 26, 26, nil, nil, - nil, nil, nil, nil, nil, nil, 26, nil, nil, 25, - nil, 54, nil, nil, nil, nil, 49, nil, nil, nil, - nil, 26, nil, nil, nil, nil, nil, 25, 25, nil, - 25, nil, nil, nil, 54, 27, 27, nil, 27, nil, - nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, - 26, nil, nil, nil, nil, nil, nil, nil, nil, nil, - 25, nil, nil, 54, nil, 54, nil, 51, 27, nil, - nil, 25, nil, 49, 51, 51, nil, nil, nil, 27, - nil, nil, nil, 54, nil, 25, 49, nil, nil, nil, - 25, 25, nil, nil, nil, nil, nil, nil, 27, 27, - 25, nil, nil, 51, nil, nil, nil, 26, 27, nil, - nil, 54, nil, nil, nil, 25, nil, nil, nil, nil, - 26, nil, 51, 27, nil, 51, nil, nil, 51, nil, + 38, 22, 53, 33, 4, 71, 69, 2, 73, 86, + 63, 29, 36, 33, 39, 67, 32, 30, 83, 64, + 38, 22, 53, 61, 22, 23, 79, 5, 47, 47, + 24, 54, 48, 38, 43, 51, 75, 37, 31, 29, + 66, 3, 38, 22, 32, 30, 38, 22, 42, 75, + 37, 42, 6, 28, 69, 50, 5, 62, 29, 21, + 58, 6, 21, 32, 30, 6, 31, 70, 59, 72, + 57, 22, 23, 64, 36, 20, 8, 5, 3, 20, + 8, 28, 58, 50, 74, 31, 34, 76, 77, 78, + 35, 3, 71, 69, 58, 80, 81, 3, 82, 67, + 28, 41, 50, 55, 24, 84, 85, 37, 1, nil, + nil, nil, nil, nil, nil, nil, nil, nil, 31, nil, + nil, nil, nil, 55, nil, nil, nil, nil, nil, nil, + nil, nil, nil, nil, 65, nil, nil, nil, 69, nil, + 42, nil, nil, nil, nil, nil, nil, nil, nil, nil, + nil, nil, 55, nil, 29, 29, nil, nil, 29, 32, + 30, nil, 39, 32, 30, 79, nil, 22, nil, nil, + nil, 22, 23, 26, 55, 3, nil, nil, nil, 54, + nil, 31, 31, 37, nil, 31, 55, nil, 38, 22, + 53, 86, 73, 36, 61, 69, 28, 28, 50, 50, + 28, 26, 50, 29, 25, 83, 71, 69, 54, 48, + nil, 5, 51, 54, 5, 37, 29, 38, 22, 53, + 26, 32, 30, nil, nil, nil, 37, 33, 29, nil, + 31, nil, 25, 32, 30, 55, nil, nil, 38, 22, + 53, 22, 29, 31, nil, 28, nil, 50, nil, 55, + nil, 25, nil, nil, nil, 31, nil, nil, 28, nil, + 50, 26, 4, nil, 26, nil, nil, nil, 27, 31, + 28, nil, 50, 65, 65, nil, nil, nil, 38, 22, + 53, nil, 29, 29, 28, nil, 50, 29, 30, 30, + nil, nil, 25, nil, nil, 25, 27, nil, nil, 65, + 31, nil, nil, 65, nil, 55, nil, 55, nil, 31, + 31, 38, 22, 53, 31, 27, 26, 26, 2, 63, + 26, nil, nil, nil, 28, 28, 50, 50, nil, 28, + nil, 50, nil, 55, nil, nil, nil, nil, nil, nil, + nil, nil, nil, nil, 29, nil, 4, 25, 25, nil, + nil, 25, nil, 26, nil, nil, 29, nil, nil, nil, + nil, 55, 38, 22, 53, 26, nil, nil, nil, nil, + nil, 31, 38, 22, 53, 38, 22, 53, 26, nil, + 55, 55, nil, 31, 25, nil, 28, nil, 50, nil, + 26, nil, 52, nil, 52, 52, 25, nil, 28, nil, + 50, nil, nil, 55, 26, nil, nil, nil, nil, 25, + nil, 27, 27, nil, nil, 27, nil, nil, 52, nil, + nil, 25, nil, nil, nil, nil, nil, nil, nil, nil, + nil, nil, nil, nil, nil, 25, nil, 52, nil, nil, + 26, nil, 52, nil, 26, 26, 52, nil, nil, 26, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, - 54, nil, 54, nil, 25, nil, nil, nil, nil, nil, - nil, nil, 27, nil, nil, nil, nil, nil, nil, nil, + 27, nil, nil, nil, nil, nil, nil, nil, nil, nil, + nil, 25, nil, 27, nil, 25, 25, nil, nil, nil, + 25, nil, nil, nil, nil, 27, nil, nil, nil, nil, + nil, nil, nil, nil, nil, nil, nil, nil, nil, 27, + nil, nil, nil, nil, nil, nil, 26, nil, nil, nil, + nil, nil, nil, nil, nil, nil, nil, nil, 26, 52, + 52, 52, nil, 52, 52, 52, 52, 52, 52, 52, + nil, 52, 52, 52, nil, nil, 52, 25, nil, 27, + 27, nil, nil, nil, 27, nil, nil, nil, nil, 25, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, - nil, nil, nil, nil, nil, nil, 54, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, - nil, 25, nil, nil, nil, nil, nil, nil, nil, 27, - nil, nil, nil, nil, 25, nil, nil, nil, nil, nil, - nil, nil, 27, nil, 51, 51, 51, nil, 51, 51, - 51, 51, 51, 51, 51, nil, 51, 51, 51, nil, - nil, 51, nil, nil, nil, nil, nil, nil, nil, nil, + nil, nil, nil, nil, nil, nil, nil, nil, nil, 52, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, - nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, - nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, - nil, nil, nil, nil, 51 ] + nil, 27, nil, nil, nil, nil, nil, nil, nil, nil, + nil, nil, nil, 27 ] racc_goto_pointer = [ - nil, 89, 10, 26, -13, 7, nil, -1, nil, nil, - nil, nil, nil, nil, nil, nil, nil, nil, nil, -7, - 48, 1, -1, -136, 116, 346, 252, 354, -15, -10, - -21, -11, 6, 19, -64, -33, -124, 0, -18, nil, - 57, -16, -153, nil, nil, nil, -189, -22, nil, 218, - -9, 528, 14, -25, 335, nil, -166, -12, -285, nil, - -54, -120, -23, -249, -13, -157, -173, nil, -147, -121, - -171, -203, -28, 38, 18, -80, 59, 23, 6, -78, - -39, -38, -113, -147, -18, -89, nil ] + nil, 108, 7, 41, -16, -161, 19, nil, 34, nil, + nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, + 33, 56, 1, 2, -136, 181, 150, 245, 30, -12, + -6, 15, -7, 2, 35, -50, -39, -105, 0, -38, + nil, 74, -63, -256, nil, nil, nil, -266, -19, nil, + 32, -16, 347, 2, -21, 74, nil, -164, -18, -263, + nil, -48, -107, -16, -261, 116, -175, -200, nil, -161, + -100, -162, -185, -24, 52, -1, -47, 70, 33, 8, + -63, -26, -24, -104, -120, 3, -94, nil ] racc_goto_default = [ - nil, nil, nil, 168, 25, 28, 32, 35, 5, 6, - 10, 13, 15, 18, 20, 24, 27, 31, 34, 4, - nil, 99, nil, 79, 101, 103, 105, 108, 109, 113, - 95, 96, 8, nil, nil, nil, nil, 85, nil, 30, - nil, nil, 161, 239, 164, 165, nil, nil, 144, 107, - 110, 111, 67, 134, 98, 150, 151, nil, 248, 104, - nil, nil, nil, nil, 69, nil, nil, 300, 80, nil, - nil, nil, nil, nil, nil, nil, nil, nil, nil, 57, - nil, nil, nil, nil, nil, nil, 192 ] + nil, nil, 278, 208, 25, nil, 31, 35, 4, 7, + 9, 14, 16, 19, 21, 24, 28, 30, 34, 3, + 6, nil, 98, nil, 76, 101, 102, 105, 107, 108, + 93, 94, 96, 12, nil, nil, nil, nil, 83, nil, + 33, nil, nil, 204, 290, 205, 206, nil, nil, 147, + 106, 109, 91, 64, 137, 97, 152, 153, nil, 259, + 104, nil, nil, nil, nil, 67, nil, nil, 301, 77, + nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, + 58, nil, nil, nil, nil, nil, nil, 197 ] racc_reduce_table = [ 0, 0, :racc_error, - 1, 70, :_reduce_1, + 1, 70, :_reduce_none, 1, 70, :_reduce_none, 1, 71, :_reduce_3, 2, 71, :_reduce_4, + 1, 74, :_reduce_5, 1, 73, :_reduce_none, 1, 73, :_reduce_none, 1, 73, :_reduce_none, @@ -695,224 +652,224 @@ racc_reduce_table = [ 1, 73, :_reduce_none, 1, 73, :_reduce_none, 1, 73, :_reduce_none, - 3, 87, :_reduce_19, - 3, 87, :_reduce_20, - 1, 88, :_reduce_none, - 1, 88, :_reduce_none, - 1, 88, :_reduce_none, + 3, 88, :_reduce_20, + 3, 88, :_reduce_21, 1, 89, :_reduce_none, 1, 89, :_reduce_none, 1, 89, :_reduce_none, - 1, 89, :_reduce_none, - 4, 81, :_reduce_28, - 5, 81, :_reduce_29, - 3, 81, :_reduce_30, - 2, 81, :_reduce_31, - 1, 91, :_reduce_none, - 1, 91, :_reduce_none, - 3, 91, :_reduce_34, - 3, 91, :_reduce_35, - 1, 92, :_reduce_none, - 1, 92, :_reduce_none, - 1, 92, :_reduce_none, - 1, 92, :_reduce_none, + 1, 90, :_reduce_none, + 1, 90, :_reduce_none, + 1, 90, :_reduce_none, + 1, 90, :_reduce_none, + 4, 82, :_reduce_29, + 5, 82, :_reduce_30, + 3, 82, :_reduce_31, + 2, 82, :_reduce_32, 1, 92, :_reduce_none, 1, 92, :_reduce_none, - 1, 92, :_reduce_none, - 1, 92, :_reduce_none, - 1, 92, :_reduce_44, - 5, 74, :_reduce_45, - 5, 74, :_reduce_46, - 5, 74, :_reduce_47, - 5, 85, :_reduce_48, - 2, 75, :_reduce_49, - 1, 108, :_reduce_50, - 2, 108, :_reduce_51, - 6, 76, :_reduce_52, - 2, 76, :_reduce_53, - 3, 109, :_reduce_54, - 3, 109, :_reduce_55, - 1, 110, :_reduce_none, - 1, 110, :_reduce_none, - 3, 110, :_reduce_58, + 3, 92, :_reduce_35, + 3, 92, :_reduce_36, + 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_45, + 5, 75, :_reduce_46, + 5, 75, :_reduce_47, + 5, 75, :_reduce_48, + 5, 86, :_reduce_49, + 2, 76, :_reduce_50, + 1, 109, :_reduce_51, + 2, 109, :_reduce_52, + 6, 77, :_reduce_53, + 2, 77, :_reduce_54, + 3, 110, :_reduce_55, + 3, 110, :_reduce_56, 1, 111, :_reduce_none, - 3, 111, :_reduce_60, - 1, 112, :_reduce_61, - 1, 112, :_reduce_62, - 3, 113, :_reduce_63, - 3, 113, :_reduce_64, - 1, 114, :_reduce_none, - 1, 114, :_reduce_none, - 4, 116, :_reduce_67, - 1, 102, :_reduce_none, - 3, 102, :_reduce_69, - 0, 103, :_reduce_none, - 1, 103, :_reduce_none, - 1, 118, :_reduce_72, - 1, 93, :_reduce_73, - 1, 95, :_reduce_74, - 1, 117, :_reduce_none, - 1, 117, :_reduce_none, - 1, 117, :_reduce_none, - 1, 117, :_reduce_none, - 1, 117, :_reduce_none, - 1, 117, :_reduce_none, - 1, 117, :_reduce_none, - 3, 77, :_reduce_82, - 3, 77, :_reduce_83, - 3, 86, :_reduce_84, - 0, 104, :_reduce_85, - 1, 104, :_reduce_86, - 3, 104, :_reduce_87, - 3, 122, :_reduce_88, - 3, 124, :_reduce_89, - 1, 125, :_reduce_none, - 1, 125, :_reduce_none, - 0, 107, :_reduce_92, - 1, 107, :_reduce_93, - 3, 107, :_reduce_94, - 1, 126, :_reduce_none, - 3, 126, :_reduce_96, - 1, 115, :_reduce_none, - 1, 115, :_reduce_none, - 1, 115, :_reduce_none, - 1, 115, :_reduce_none, + 1, 111, :_reduce_none, + 3, 111, :_reduce_59, + 1, 112, :_reduce_none, + 3, 112, :_reduce_61, + 1, 113, :_reduce_62, + 1, 113, :_reduce_63, + 3, 114, :_reduce_64, + 3, 114, :_reduce_65, 1, 115, :_reduce_none, 1, 115, :_reduce_none, - 1, 123, :_reduce_none, - 1, 123, :_reduce_none, - 1, 123, :_reduce_none, - 1, 123, :_reduce_none, - 1, 123, :_reduce_none, - 1, 123, :_reduce_none, - 1, 123, :_reduce_none, - 1, 123, :_reduce_none, - 1, 123, :_reduce_none, - 1, 123, :_reduce_none, - 1, 123, :_reduce_none, - 1, 123, :_reduce_none, - 4, 97, :_reduce_115, - 3, 97, :_reduce_116, - 1, 99, :_reduce_117, - 2, 99, :_reduce_118, - 2, 129, :_reduce_119, - 1, 130, :_reduce_120, - 2, 130, :_reduce_121, - 1, 96, :_reduce_122, - 4, 90, :_reduce_123, - 4, 90, :_reduce_124, - 2, 79, :_reduce_125, - 5, 131, :_reduce_126, - 4, 131, :_reduce_127, - 0, 132, :_reduce_none, - 2, 132, :_reduce_129, - 4, 132, :_reduce_130, - 3, 132, :_reduce_131, - 1, 120, :_reduce_none, - 3, 120, :_reduce_133, - 3, 120, :_reduce_134, - 3, 120, :_reduce_135, - 3, 120, :_reduce_136, - 3, 120, :_reduce_137, - 3, 120, :_reduce_138, - 3, 120, :_reduce_139, - 3, 120, :_reduce_140, - 3, 120, :_reduce_141, - 2, 120, :_reduce_142, - 3, 120, :_reduce_143, - 3, 120, :_reduce_144, - 3, 120, :_reduce_145, - 3, 120, :_reduce_146, - 3, 120, :_reduce_147, - 3, 120, :_reduce_148, - 2, 120, :_reduce_149, - 3, 120, :_reduce_150, - 3, 120, :_reduce_151, - 3, 120, :_reduce_152, - 5, 78, :_reduce_153, - 1, 134, :_reduce_none, - 2, 134, :_reduce_155, - 5, 135, :_reduce_156, - 4, 135, :_reduce_157, - 1, 136, :_reduce_none, - 3, 136, :_reduce_159, - 3, 98, :_reduce_160, - 1, 138, :_reduce_none, - 4, 138, :_reduce_162, - 1, 140, :_reduce_none, - 3, 140, :_reduce_164, - 3, 139, :_reduce_165, - 1, 137, :_reduce_none, - 1, 137, :_reduce_none, - 1, 137, :_reduce_none, - 1, 137, :_reduce_none, - 1, 137, :_reduce_none, - 1, 137, :_reduce_none, - 1, 137, :_reduce_none, - 1, 137, :_reduce_173, + 4, 117, :_reduce_68, + 1, 103, :_reduce_none, + 3, 103, :_reduce_70, + 0, 104, :_reduce_none, + 1, 104, :_reduce_none, + 1, 119, :_reduce_73, + 1, 94, :_reduce_74, + 1, 96, :_reduce_75, + 1, 118, :_reduce_none, + 1, 118, :_reduce_none, + 1, 118, :_reduce_none, + 1, 118, :_reduce_none, + 1, 118, :_reduce_none, + 1, 118, :_reduce_none, + 1, 118, :_reduce_none, + 3, 78, :_reduce_83, + 3, 78, :_reduce_84, + 3, 87, :_reduce_85, + 0, 105, :_reduce_86, + 1, 105, :_reduce_87, + 3, 105, :_reduce_88, + 3, 123, :_reduce_89, + 3, 125, :_reduce_90, + 1, 126, :_reduce_none, + 1, 126, :_reduce_none, + 0, 108, :_reduce_93, + 1, 108, :_reduce_94, + 3, 108, :_reduce_95, + 1, 127, :_reduce_none, + 3, 127, :_reduce_97, + 1, 116, :_reduce_none, + 1, 116, :_reduce_none, + 1, 116, :_reduce_none, + 1, 116, :_reduce_none, + 1, 116, :_reduce_none, + 1, 116, :_reduce_none, + 1, 124, :_reduce_none, + 1, 124, :_reduce_none, + 1, 124, :_reduce_none, + 1, 124, :_reduce_none, + 1, 124, :_reduce_none, + 1, 124, :_reduce_none, + 1, 124, :_reduce_none, + 1, 124, :_reduce_none, + 1, 124, :_reduce_none, + 1, 124, :_reduce_none, + 1, 124, :_reduce_none, + 1, 124, :_reduce_none, + 4, 98, :_reduce_116, + 3, 98, :_reduce_117, + 1, 100, :_reduce_118, + 2, 100, :_reduce_119, + 2, 130, :_reduce_120, + 1, 131, :_reduce_121, + 2, 131, :_reduce_122, + 1, 97, :_reduce_123, + 4, 91, :_reduce_124, + 4, 91, :_reduce_125, + 2, 80, :_reduce_126, + 5, 132, :_reduce_127, + 4, 132, :_reduce_128, + 0, 133, :_reduce_none, + 2, 133, :_reduce_130, + 4, 133, :_reduce_131, + 3, 133, :_reduce_132, + 1, 121, :_reduce_none, + 3, 121, :_reduce_134, + 3, 121, :_reduce_135, + 3, 121, :_reduce_136, + 3, 121, :_reduce_137, + 3, 121, :_reduce_138, + 3, 121, :_reduce_139, + 3, 121, :_reduce_140, + 3, 121, :_reduce_141, + 3, 121, :_reduce_142, + 2, 121, :_reduce_143, + 3, 121, :_reduce_144, + 3, 121, :_reduce_145, + 3, 121, :_reduce_146, + 3, 121, :_reduce_147, + 3, 121, :_reduce_148, + 3, 121, :_reduce_149, + 2, 121, :_reduce_150, + 3, 121, :_reduce_151, + 3, 121, :_reduce_152, + 3, 121, :_reduce_153, + 5, 79, :_reduce_154, + 1, 135, :_reduce_none, + 2, 135, :_reduce_156, + 5, 136, :_reduce_157, + 4, 136, :_reduce_158, 1, 137, :_reduce_none, - 1, 141, :_reduce_175, - 1, 142, :_reduce_none, - 3, 142, :_reduce_177, - 2, 80, :_reduce_178, - 6, 82, :_reduce_179, - 5, 82, :_reduce_180, - 7, 83, :_reduce_181, - 6, 83, :_reduce_182, + 3, 137, :_reduce_160, + 3, 99, :_reduce_161, + 1, 139, :_reduce_none, + 4, 139, :_reduce_163, + 1, 141, :_reduce_none, + 3, 141, :_reduce_165, + 3, 140, :_reduce_166, + 1, 138, :_reduce_none, + 1, 138, :_reduce_none, + 1, 138, :_reduce_none, + 1, 138, :_reduce_none, + 1, 138, :_reduce_none, + 1, 138, :_reduce_none, + 1, 138, :_reduce_none, + 1, 138, :_reduce_174, + 1, 138, :_reduce_none, + 1, 142, :_reduce_176, + 1, 143, :_reduce_none, + 3, 143, :_reduce_178, + 2, 81, :_reduce_179, + 6, 83, :_reduce_180, + 5, 83, :_reduce_181, + 7, 84, :_reduce_182, 6, 84, :_reduce_183, - 5, 84, :_reduce_184, - 1, 106, :_reduce_185, - 1, 101, :_reduce_186, - 1, 101, :_reduce_187, - 1, 101, :_reduce_188, - 1, 145, :_reduce_189, - 3, 145, :_reduce_190, - 1, 147, :_reduce_191, + 6, 85, :_reduce_184, + 5, 85, :_reduce_185, + 1, 107, :_reduce_186, + 1, 102, :_reduce_187, + 1, 102, :_reduce_188, + 1, 102, :_reduce_189, + 1, 146, :_reduce_190, + 3, 146, :_reduce_191, 1, 148, :_reduce_192, - 1, 148, :_reduce_193, - 1, 148, :_reduce_194, - 1, 148, :_reduce_none, - 0, 72, :_reduce_196, - 0, 149, :_reduce_197, - 1, 143, :_reduce_none, - 3, 143, :_reduce_199, - 3, 143, :_reduce_200, - 1, 150, :_reduce_none, - 3, 150, :_reduce_202, - 3, 151, :_reduce_203, - 1, 151, :_reduce_204, - 3, 151, :_reduce_205, - 1, 151, :_reduce_206, - 1, 146, :_reduce_none, - 2, 146, :_reduce_208, + 1, 149, :_reduce_193, + 1, 149, :_reduce_194, + 1, 149, :_reduce_195, + 1, 149, :_reduce_none, + 0, 72, :_reduce_197, + 0, 150, :_reduce_198, 1, 144, :_reduce_none, - 2, 144, :_reduce_210, - 1, 152, :_reduce_none, - 1, 152, :_reduce_none, - 1, 94, :_reduce_213, - 3, 119, :_reduce_214, - 4, 119, :_reduce_215, - 2, 119, :_reduce_216, - 1, 127, :_reduce_none, - 1, 127, :_reduce_none, - 0, 105, :_reduce_none, - 1, 105, :_reduce_220, - 1, 133, :_reduce_221, - 3, 128, :_reduce_222, - 4, 128, :_reduce_223, - 2, 128, :_reduce_224, + 3, 144, :_reduce_200, + 3, 144, :_reduce_201, + 1, 151, :_reduce_none, + 3, 151, :_reduce_203, + 3, 152, :_reduce_204, + 1, 152, :_reduce_205, + 3, 152, :_reduce_206, + 1, 152, :_reduce_207, + 1, 147, :_reduce_none, + 2, 147, :_reduce_209, + 1, 145, :_reduce_none, + 2, 145, :_reduce_211, 1, 153, :_reduce_none, - 3, 153, :_reduce_226, + 1, 153, :_reduce_none, + 1, 95, :_reduce_214, + 3, 120, :_reduce_215, + 4, 120, :_reduce_216, + 2, 120, :_reduce_217, + 1, 128, :_reduce_none, + 1, 128, :_reduce_none, + 0, 106, :_reduce_none, + 1, 106, :_reduce_221, + 1, 134, :_reduce_222, + 3, 129, :_reduce_223, + 4, 129, :_reduce_224, + 2, 129, :_reduce_225, + 1, 154, :_reduce_none, 3, 154, :_reduce_227, - 1, 155, :_reduce_228, - 1, 155, :_reduce_229, - 4, 121, :_reduce_230, - 1, 100, :_reduce_none, - 4, 100, :_reduce_232 ] + 3, 155, :_reduce_228, + 1, 156, :_reduce_229, + 1, 156, :_reduce_230, + 4, 122, :_reduce_231, + 1, 101, :_reduce_none, + 4, 101, :_reduce_233 ] -racc_reduce_n = 233 +racc_reduce_n = 234 -racc_shift_n = 384 +racc_shift_n = 385 racc_token_table = { false => 0, @@ -1077,9 +1034,10 @@ Racc_token_to_s_table = [ "IN", "$start", "program", - "statements", + "statements_and_declarations", "nil", - "statement", + "statement_or_declaration", + "statements", "resource", "virtualresource", "collection", @@ -1169,18 +1127,11 @@ Racc_debug_parser = false # reduce 0 omitted -module_eval(<<'.,.,', 'grammar.ra', 31) - def _reduce_1(val, _values, result) - val[0].is_a_namespace = true - result = val[0] - - result - end -.,., +# reduce 1 omitted # reduce 2 omitted -module_eval(<<'.,.,', 'grammar.ra', 37) +module_eval(<<'.,.,', 'grammar.ra', 34) def _reduce_3(val, _values, result) result = ast AST::ASTArray, :children => [val[0]] @@ -1188,7 +1139,7 @@ module_eval(<<'.,.,', 'grammar.ra', 37) end .,., -module_eval(<<'.,.,', 'grammar.ra', 40) +module_eval(<<'.,.,', 'grammar.ra', 37) def _reduce_4(val, _values, result) val[0].push(val[1]) result = val[0] @@ -1197,7 +1148,18 @@ module_eval(<<'.,.,', 'grammar.ra', 40) end .,., -# reduce 5 omitted +module_eval(<<'.,.,', 'grammar.ra', 44) + def _reduce_5(val, _values, result) + 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" + end + end + result = val[0] + + result + end +.,., # reduce 6 omitted @@ -1225,24 +1187,24 @@ module_eval(<<'.,.,', 'grammar.ra', 40) # reduce 18 omitted -module_eval(<<'.,.,', 'grammar.ra', 61) - def _reduce_19(val, _values, result) +# reduce 19 omitted + +module_eval(<<'.,.,', 'grammar.ra', 69) + def _reduce_20(val, _values, result) result = AST::Relationship.new(val[0], val[2], val[1][:value], ast_context) result end .,., -module_eval(<<'.,.,', 'grammar.ra', 64) - def _reduce_20(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 72) + def _reduce_21(val, _values, result) result = AST::Relationship.new(val[0], val[2], val[1][:value], ast_context) result end .,., -# reduce 21 omitted - # reduce 22 omitted # reduce 23 omitted @@ -1255,8 +1217,10 @@ module_eval(<<'.,.,', 'grammar.ra', 64) # reduce 27 omitted -module_eval(<<'.,.,', 'grammar.ra', 72) - def _reduce_28(val, _values, result) +# reduce 28 omitted + +module_eval(<<'.,.,', 'grammar.ra', 80) + def _reduce_29(val, _values, result) args = aryfy(val[2]) result = ast AST::Function, :name => val[0][:value], @@ -1268,8 +1232,8 @@ module_eval(<<'.,.,', 'grammar.ra', 72) end .,., -module_eval(<<'.,.,', 'grammar.ra', 80) - def _reduce_29(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 88) + def _reduce_30(val, _values, result) args = aryfy(val[2]) result = ast AST::Function, :name => val[0][:value], @@ -1281,8 +1245,8 @@ module_eval(<<'.,.,', 'grammar.ra', 80) end .,., -module_eval(<<'.,.,', 'grammar.ra', 87) - def _reduce_30(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 95) + def _reduce_31(val, _values, result) result = ast AST::Function, :name => val[0][:value], :line => val[0][:line], @@ -1293,8 +1257,8 @@ module_eval(<<'.,.,', 'grammar.ra', 87) end .,., -module_eval(<<'.,.,', 'grammar.ra', 94) - def _reduce_31(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 102) + def _reduce_32(val, _values, result) args = aryfy(val[1]) result = ast AST::Function, :name => val[0][:value], @@ -1306,12 +1270,12 @@ module_eval(<<'.,.,', 'grammar.ra', 94) end .,., -# reduce 32 omitted - # reduce 33 omitted -module_eval(<<'.,.,', 'grammar.ra', 105) - def _reduce_34(val, _values, result) +# reduce 34 omitted + +module_eval(<<'.,.,', 'grammar.ra', 113) + def _reduce_35(val, _values, result) result = aryfy(val[0], val[2]) result.line = @lexer.line result.file = @lexer.file @@ -1320,8 +1284,8 @@ module_eval(<<'.,.,', 'grammar.ra', 105) end .,., -module_eval(<<'.,.,', 'grammar.ra', 110) - def _reduce_35(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 118) + def _reduce_36(val, _values, result) unless val[0].is_a?(AST::ASTArray) val[0] = aryfy(val[0]) end @@ -1334,8 +1298,6 @@ module_eval(<<'.,.,', 'grammar.ra', 110) end .,., -# reduce 36 omitted - # reduce 37 omitted # reduce 38 omitted @@ -1350,16 +1312,18 @@ module_eval(<<'.,.,', 'grammar.ra', 110) # reduce 43 omitted -module_eval(<<'.,.,', 'grammar.ra', 130) - def _reduce_44(val, _values, result) +# reduce 44 omitted + +module_eval(<<'.,.,', 'grammar.ra', 138) + def _reduce_45(val, _values, result) result = ast AST::Name, :value => val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 134) - def _reduce_45(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 142) + def _reduce_46(val, _values, result) @lexer.commentpop array = val[2] array = [array] if array.instance_of?(AST::ResourceInstance) @@ -1383,8 +1347,8 @@ module_eval(<<'.,.,', 'grammar.ra', 134) end .,., -module_eval(<<'.,.,', 'grammar.ra', 153) - def _reduce_46(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 161) + def _reduce_47(val, _values, result) # This is a deprecated syntax. error "All resource specifications require names" @@ -1392,8 +1356,8 @@ module_eval(<<'.,.,', 'grammar.ra', 153) end .,., -module_eval(<<'.,.,', 'grammar.ra', 156) - def _reduce_47(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 164) + def _reduce_48(val, _values, result) # a defaults setting for a type @lexer.commentpop result = ast(AST::ResourceDefaults, :type => val[0], :parameters => val[2]) @@ -1402,8 +1366,8 @@ module_eval(<<'.,.,', 'grammar.ra', 156) end .,., -module_eval(<<'.,.,', 'grammar.ra', 163) - def _reduce_48(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 171) + def _reduce_49(val, _values, result) @lexer.commentpop result = ast AST::ResourceOverride, :object => val[0], :parameters => val[2] @@ -1411,8 +1375,8 @@ module_eval(<<'.,.,', 'grammar.ra', 163) end .,., -module_eval(<<'.,.,', 'grammar.ra', 170) - def _reduce_49(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 178) + def _reduce_50(val, _values, result) type = val[0] if (type == :exported and ! Puppet[:storeconfigs]) and ! Puppet[:parseonly] @@ -1438,22 +1402,22 @@ module_eval(<<'.,.,', 'grammar.ra', 170) end .,., -module_eval(<<'.,.,', 'grammar.ra', 192) - def _reduce_50(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 200) + def _reduce_51(val, _values, result) result = :virtual result end .,., -module_eval(<<'.,.,', 'grammar.ra', 193) - def _reduce_51(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 201) + def _reduce_52(val, _values, result) result = :exported result end .,., -module_eval(<<'.,.,', 'grammar.ra', 198) - def _reduce_52(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 206) + def _reduce_53(val, _values, result) @lexer.commentpop Puppet.warning addcontext("Collection names must now be capitalized") if val[0] =~ /^[a-z]/ type = val[0].downcase @@ -1476,8 +1440,8 @@ module_eval(<<'.,.,', 'grammar.ra', 198) end .,., -module_eval(<<'.,.,', 'grammar.ra', 217) - def _reduce_53(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 225) + def _reduce_54(val, _values, result) if val[0] =~ /^[a-z]/ Puppet.warning addcontext("Collection names must now be capitalized") end @@ -1500,8 +1464,8 @@ module_eval(<<'.,.,', 'grammar.ra', 217) end .,., -module_eval(<<'.,.,', 'grammar.ra', 238) - def _reduce_54(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 246) + def _reduce_55(val, _values, result) if val[1] result = val[1] result.form = :virtual @@ -1513,8 +1477,8 @@ module_eval(<<'.,.,', 'grammar.ra', 238) end .,., -module_eval(<<'.,.,', 'grammar.ra', 246) - def _reduce_55(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 254) + def _reduce_56(val, _values, result) if val[1] result = val[1] result.form = :exported @@ -1526,22 +1490,22 @@ module_eval(<<'.,.,', 'grammar.ra', 246) end .,., -# reduce 56 omitted - # reduce 57 omitted -module_eval(<<'.,.,', 'grammar.ra', 259) - def _reduce_58(val, _values, result) +# reduce 58 omitted + +module_eval(<<'.,.,', 'grammar.ra', 267) + def _reduce_59(val, _values, result) result = ast AST::CollExpr, :test1 => val[0], :oper => val[1], :test2 => val[2] result end .,., -# reduce 59 omitted +# reduce 60 omitted -module_eval(<<'.,.,', 'grammar.ra', 264) - def _reduce_60(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 272) + def _reduce_61(val, _values, result) result = val[1] result.parens = true @@ -1549,22 +1513,22 @@ module_eval(<<'.,.,', 'grammar.ra', 264) end .,., -module_eval(<<'.,.,', 'grammar.ra', 268) - def _reduce_61(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 276) + def _reduce_62(val, _values, result) result=val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 269) - def _reduce_62(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 277) + def _reduce_63(val, _values, result) result=val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 272) - def _reduce_63(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 280) + def _reduce_64(val, _values, result) result = ast AST::CollExpr, :test1 => val[0], :oper => val[1][:value], :test2 => val[2] #result = ast AST::CollExpr #result.push *val @@ -1573,8 +1537,8 @@ module_eval(<<'.,.,', 'grammar.ra', 272) end .,., -module_eval(<<'.,.,', 'grammar.ra', 277) - def _reduce_64(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 285) + def _reduce_65(val, _values, result) result = ast AST::CollExpr, :test1 => val[0], :oper => val[1][:value], :test2 => val[2] #result = ast AST::CollExpr #result.push *val @@ -1583,22 +1547,22 @@ module_eval(<<'.,.,', 'grammar.ra', 277) end .,., -# reduce 65 omitted - # reduce 66 omitted -module_eval(<<'.,.,', 'grammar.ra', 286) - def _reduce_67(val, _values, result) +# reduce 67 omitted + +module_eval(<<'.,.,', 'grammar.ra', 294) + def _reduce_68(val, _values, result) result = ast AST::ResourceInstance, :children => [val[0],val[2]] result end .,., -# reduce 68 omitted +# reduce 69 omitted -module_eval(<<'.,.,', 'grammar.ra', 291) - def _reduce_69(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 299) + def _reduce_70(val, _values, result) if val[0].instance_of?(AST::ResourceInstance) result = ast AST::ASTArray, :children => [val[0],val[2]] else @@ -1610,36 +1574,34 @@ module_eval(<<'.,.,', 'grammar.ra', 291) end .,., -# reduce 70 omitted - # reduce 71 omitted -module_eval(<<'.,.,', 'grammar.ra', 303) - def _reduce_72(val, _values, result) +# reduce 72 omitted + +module_eval(<<'.,.,', 'grammar.ra', 311) + def _reduce_73(val, _values, result) result = ast AST::Undef, :value => :undef result end .,., -module_eval(<<'.,.,', 'grammar.ra', 307) - def _reduce_73(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 315) + def _reduce_74(val, _values, result) result = ast AST::Name, :value => val[0][:value], :line => val[0][:line] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 311) - def _reduce_74(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 319) + def _reduce_75(val, _values, result) result = ast AST::Type, :value => val[0][:value], :line => val[0][:line] result end .,., -# reduce 75 omitted - # reduce 76 omitted # reduce 77 omitted @@ -1652,8 +1614,10 @@ module_eval(<<'.,.,', 'grammar.ra', 311) # reduce 81 omitted -module_eval(<<'.,.,', 'grammar.ra', 323) - def _reduce_82(val, _values, result) +# reduce 82 omitted + +module_eval(<<'.,.,', 'grammar.ra', 331) + def _reduce_83(val, _values, result) 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] @@ -1663,16 +1627,16 @@ module_eval(<<'.,.,', 'grammar.ra', 323) end .,., -module_eval(<<'.,.,', 'grammar.ra', 329) - def _reduce_83(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 337) + def _reduce_84(val, _values, result) result = ast AST::VarDef, :name => val[0], :value => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 333) - def _reduce_84(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 341) + def _reduce_85(val, _values, result) 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] @@ -1680,23 +1644,23 @@ module_eval(<<'.,.,', 'grammar.ra', 333) end .,., -module_eval(<<'.,.,', 'grammar.ra', 339) - def _reduce_85(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 347) + def _reduce_86(val, _values, result) result = ast AST::ASTArray result end .,., -module_eval(<<'.,.,', 'grammar.ra', 341) - def _reduce_86(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 349) + def _reduce_87(val, _values, result) result = val[0] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 343) - def _reduce_87(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 351) + def _reduce_88(val, _values, result) if val[0].instance_of?(AST::ASTArray) val[0].push(val[2]) result = val[0] @@ -1708,16 +1672,16 @@ module_eval(<<'.,.,', 'grammar.ra', 343) end .,., -module_eval(<<'.,.,', 'grammar.ra', 352) - def _reduce_88(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 360) + def _reduce_89(val, _values, result) result = ast AST::ResourceParam, :param => val[0][:value], :line => val[0][:line], :value => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 356) - def _reduce_89(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 364) + def _reduce_90(val, _values, result) result = ast AST::ResourceParam, :param => val[0][:value], :line => val[0][:line], :value => val[2], :add => true @@ -1725,27 +1689,27 @@ module_eval(<<'.,.,', 'grammar.ra', 356) end .,., -# reduce 90 omitted - # reduce 91 omitted -module_eval(<<'.,.,', 'grammar.ra', 365) - def _reduce_92(val, _values, result) +# reduce 92 omitted + +module_eval(<<'.,.,', 'grammar.ra', 373) + def _reduce_93(val, _values, result) result = ast AST::ASTArray result end .,., -module_eval(<<'.,.,', 'grammar.ra', 367) - def _reduce_93(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 375) + def _reduce_94(val, _values, result) result = val[0] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 369) - def _reduce_94(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 377) + def _reduce_95(val, _values, result) if val[0].instance_of?(AST::ASTArray) val[0].push(val[2]) result = val[0] @@ -1757,10 +1721,10 @@ module_eval(<<'.,.,', 'grammar.ra', 369) end .,., -# reduce 95 omitted +# reduce 96 omitted -module_eval(<<'.,.,', 'grammar.ra', 379) - def _reduce_96(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 387) + def _reduce_97(val, _values, result) if val[0].instance_of?(AST::ASTArray) result = val[0].push(val[2]) else @@ -1771,8 +1735,6 @@ module_eval(<<'.,.,', 'grammar.ra', 379) end .,., -# reduce 97 omitted - # reduce 98 omitted # reduce 99 omitted @@ -1807,8 +1769,10 @@ module_eval(<<'.,.,', 'grammar.ra', 379) # reduce 114 omitted -module_eval(<<'.,.,', 'grammar.ra', 408) - def _reduce_115(val, _values, result) +# reduce 115 omitted + +module_eval(<<'.,.,', 'grammar.ra', 416) + def _reduce_116(val, _values, result) args = aryfy(val[2]) result = ast AST::Function, :name => val[0][:value], :line => val[0][:line], @@ -1819,8 +1783,8 @@ module_eval(<<'.,.,', 'grammar.ra', 408) end .,., -module_eval(<<'.,.,', 'grammar.ra', 414) - def _reduce_116(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 422) + def _reduce_117(val, _values, result) result = ast AST::Function, :name => val[0][:value], :line => val[0][:line], :arguments => AST::ASTArray.new({}), @@ -1830,51 +1794,51 @@ module_eval(<<'.,.,', 'grammar.ra', 414) end .,., -module_eval(<<'.,.,', 'grammar.ra', 420) - def _reduce_117(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 428) + def _reduce_118(val, _values, result) result = ast AST::String, :value => val[0][:value], :line => val[0][:line] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 421) - def _reduce_118(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 429) + def _reduce_119(val, _values, result) result = ast AST::Concat, :value => [ast(AST::String,val[0])]+val[1], :line => val[0][:line] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 423) - def _reduce_119(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 431) + def _reduce_120(val, _values, result) result = [val[0]] + val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 425) - def _reduce_120(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 433) + def _reduce_121(val, _values, result) result = [ast(AST::String,val[0])] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 426) - def _reduce_121(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 434) + def _reduce_122(val, _values, result) result = [ast(AST::String,val[0])] + val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 429) - def _reduce_122(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 437) + def _reduce_123(val, _values, result) result = ast AST::Boolean, :value => val[0][:value], :line => val[0][:line] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 433) - def _reduce_123(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 441) + def _reduce_124(val, _values, result) 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] @@ -1882,24 +1846,24 @@ module_eval(<<'.,.,', 'grammar.ra', 433) end .,., -module_eval(<<'.,.,', 'grammar.ra', 436) - def _reduce_124(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 444) + def _reduce_125(val, _values, result) result = ast AST::ResourceReference, :type => val[0], :title => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 440) - def _reduce_125(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 448) + def _reduce_126(val, _values, result) result = val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 444) - def _reduce_126(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 452) + def _reduce_127(val, _values, result) @lexer.commentpop args = { :test => val[0], @@ -1914,8 +1878,8 @@ module_eval(<<'.,.,', 'grammar.ra', 444) end .,., -module_eval(<<'.,.,', 'grammar.ra', 455) - def _reduce_127(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 463) + def _reduce_128(val, _values, result) @lexer.commentpop args = { :test => val[0], @@ -1930,18 +1894,18 @@ module_eval(<<'.,.,', 'grammar.ra', 455) end .,., -# reduce 128 omitted +# reduce 129 omitted -module_eval(<<'.,.,', 'grammar.ra', 468) - def _reduce_129(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 476) + def _reduce_130(val, _values, result) result = ast AST::Else, :statements => val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 471) - def _reduce_130(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 479) + def _reduce_131(val, _values, result) @lexer.commentpop result = ast AST::Else, :statements => val[2] @@ -1949,8 +1913,8 @@ module_eval(<<'.,.,', 'grammar.ra', 471) end .,., -module_eval(<<'.,.,', 'grammar.ra', 475) - def _reduce_131(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 483) + def _reduce_132(val, _values, result) @lexer.commentpop result = ast AST::Else, :statements => ast(AST::Nop) @@ -1958,25 +1922,17 @@ module_eval(<<'.,.,', 'grammar.ra', 475) end .,., -# reduce 132 omitted +# reduce 133 omitted -module_eval(<<'.,.,', 'grammar.ra', 493) - def _reduce_133(val, _values, result) - result = ast AST::InOperator, :lval => val[0], :rval => val[2] - - result - end -.,., - -module_eval(<<'.,.,', 'grammar.ra', 496) +module_eval(<<'.,.,', 'grammar.ra', 501) def _reduce_134(val, _values, result) - result = ast AST::MatchOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] + result = ast AST::InOperator, :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 499) +module_eval(<<'.,.,', 'grammar.ra', 504) def _reduce_135(val, _values, result) result = ast AST::MatchOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -1984,15 +1940,15 @@ module_eval(<<'.,.,', 'grammar.ra', 499) end .,., -module_eval(<<'.,.,', 'grammar.ra', 502) +module_eval(<<'.,.,', 'grammar.ra', 507) def _reduce_136(val, _values, result) - result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] + result = ast AST::MatchOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 505) +module_eval(<<'.,.,', 'grammar.ra', 510) def _reduce_137(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2000,7 +1956,7 @@ module_eval(<<'.,.,', 'grammar.ra', 505) end .,., -module_eval(<<'.,.,', 'grammar.ra', 508) +module_eval(<<'.,.,', 'grammar.ra', 513) def _reduce_138(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2008,7 +1964,7 @@ module_eval(<<'.,.,', 'grammar.ra', 508) end .,., -module_eval(<<'.,.,', 'grammar.ra', 511) +module_eval(<<'.,.,', 'grammar.ra', 516) def _reduce_139(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2016,7 +1972,7 @@ module_eval(<<'.,.,', 'grammar.ra', 511) end .,., -module_eval(<<'.,.,', 'grammar.ra', 514) +module_eval(<<'.,.,', 'grammar.ra', 519) def _reduce_140(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2024,7 +1980,7 @@ module_eval(<<'.,.,', 'grammar.ra', 514) end .,., -module_eval(<<'.,.,', 'grammar.ra', 517) +module_eval(<<'.,.,', 'grammar.ra', 522) def _reduce_141(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2032,23 +1988,23 @@ module_eval(<<'.,.,', 'grammar.ra', 517) end .,., -module_eval(<<'.,.,', 'grammar.ra', 520) +module_eval(<<'.,.,', 'grammar.ra', 525) def _reduce_142(val, _values, result) - result = ast AST::Minus, :value => val[1] + result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 523) +module_eval(<<'.,.,', 'grammar.ra', 528) def _reduce_143(val, _values, result) - result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] + result = ast AST::Minus, :value => val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 526) +module_eval(<<'.,.,', 'grammar.ra', 531) def _reduce_144(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2056,7 +2012,7 @@ module_eval(<<'.,.,', 'grammar.ra', 526) end .,., -module_eval(<<'.,.,', 'grammar.ra', 529) +module_eval(<<'.,.,', 'grammar.ra', 534) def _reduce_145(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2064,7 +2020,7 @@ module_eval(<<'.,.,', 'grammar.ra', 529) end .,., -module_eval(<<'.,.,', 'grammar.ra', 532) +module_eval(<<'.,.,', 'grammar.ra', 537) def _reduce_146(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2072,7 +2028,7 @@ module_eval(<<'.,.,', 'grammar.ra', 532) end .,., -module_eval(<<'.,.,', 'grammar.ra', 535) +module_eval(<<'.,.,', 'grammar.ra', 540) def _reduce_147(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2080,7 +2036,7 @@ module_eval(<<'.,.,', 'grammar.ra', 535) end .,., -module_eval(<<'.,.,', 'grammar.ra', 538) +module_eval(<<'.,.,', 'grammar.ra', 543) def _reduce_148(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2088,23 +2044,23 @@ module_eval(<<'.,.,', 'grammar.ra', 538) end .,., -module_eval(<<'.,.,', 'grammar.ra', 541) +module_eval(<<'.,.,', 'grammar.ra', 546) def _reduce_149(val, _values, result) - result = ast AST::Not, :value => val[1] + result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 544) +module_eval(<<'.,.,', 'grammar.ra', 549) def _reduce_150(val, _values, result) - result = ast AST::BooleanOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] + result = ast AST::Not, :value => val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 547) +module_eval(<<'.,.,', 'grammar.ra', 552) def _reduce_151(val, _values, result) result = ast AST::BooleanOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2112,16 +2068,24 @@ module_eval(<<'.,.,', 'grammar.ra', 547) end .,., -module_eval(<<'.,.,', 'grammar.ra', 550) +module_eval(<<'.,.,', 'grammar.ra', 555) def _reduce_152(val, _values, result) - result = val[1] + result = ast AST::BooleanOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 554) +module_eval(<<'.,.,', 'grammar.ra', 558) def _reduce_153(val, _values, result) + result = val[1] + + result + end +.,., + +module_eval(<<'.,.,', 'grammar.ra', 562) + def _reduce_154(val, _values, result) @lexer.commentpop options = val[3] options = ast AST::ASTArray, :children => [val[3]] unless options.instance_of?(AST::ASTArray) @@ -2131,10 +2095,10 @@ module_eval(<<'.,.,', 'grammar.ra', 554) end .,., -# reduce 154 omitted +# reduce 155 omitted -module_eval(<<'.,.,', 'grammar.ra', 562) - def _reduce_155(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 570) + def _reduce_156(val, _values, result) if val[0].instance_of?(AST::ASTArray) val[0].push val[1] result = val[0] @@ -2146,8 +2110,8 @@ module_eval(<<'.,.,', 'grammar.ra', 562) end .,., -module_eval(<<'.,.,', 'grammar.ra', 571) - def _reduce_156(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 579) + def _reduce_157(val, _values, result) @lexer.commentpop result = ast AST::CaseOpt, :value => val[0], :statements => val[3] @@ -2155,8 +2119,8 @@ module_eval(<<'.,.,', 'grammar.ra', 571) end .,., -module_eval(<<'.,.,', 'grammar.ra', 574) - def _reduce_157(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 582) + def _reduce_158(val, _values, result) @lexer.commentpop result = ast( @@ -2170,10 +2134,10 @@ module_eval(<<'.,.,', 'grammar.ra', 574) end .,., -# reduce 158 omitted +# reduce 159 omitted -module_eval(<<'.,.,', 'grammar.ra', 586) - def _reduce_159(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 594) + def _reduce_160(val, _values, result) if val[0].instance_of?(AST::ASTArray) val[0].push(val[2]) result = val[0] @@ -2185,18 +2149,18 @@ module_eval(<<'.,.,', 'grammar.ra', 586) end .,., -module_eval(<<'.,.,', 'grammar.ra', 595) - def _reduce_160(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 603) + def _reduce_161(val, _values, result) result = ast AST::Selector, :param => val[0], :values => val[2] result end .,., -# reduce 161 omitted +# reduce 162 omitted -module_eval(<<'.,.,', 'grammar.ra', 600) - def _reduce_162(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 608) + def _reduce_163(val, _values, result) @lexer.commentpop result = val[1] @@ -2204,10 +2168,10 @@ module_eval(<<'.,.,', 'grammar.ra', 600) end .,., -# reduce 163 omitted +# reduce 164 omitted -module_eval(<<'.,.,', 'grammar.ra', 606) - def _reduce_164(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 614) + def _reduce_165(val, _values, result) if val[0].instance_of?(AST::ASTArray) val[0].push(val[2]) result = val[0] @@ -2219,16 +2183,14 @@ module_eval(<<'.,.,', 'grammar.ra', 606) end .,., -module_eval(<<'.,.,', 'grammar.ra', 615) - def _reduce_165(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 623) + def _reduce_166(val, _values, result) result = ast AST::ResourceParam, :param => val[0], :value => val[2] result end .,., -# reduce 166 omitted - # reduce 167 omitted # reduce 168 omitted @@ -2241,34 +2203,36 @@ module_eval(<<'.,.,', 'grammar.ra', 615) # reduce 172 omitted -module_eval(<<'.,.,', 'grammar.ra', 626) - def _reduce_173(val, _values, result) +# reduce 173 omitted + +module_eval(<<'.,.,', 'grammar.ra', 634) + def _reduce_174(val, _values, result) result = ast AST::Default, :value => val[0][:value], :line => val[0][:line] result end .,., -# reduce 174 omitted +# reduce 175 omitted -module_eval(<<'.,.,', 'grammar.ra', 631) - def _reduce_175(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 639) + def _reduce_176(val, _values, result) result = [val[0][:value]] result end .,., -# reduce 176 omitted +# reduce 177 omitted -module_eval(<<'.,.,', 'grammar.ra', 633) - def _reduce_177(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 641) + def _reduce_178(val, _values, result) result = val[0] += val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 636) - def _reduce_178(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 644) + def _reduce_179(val, _values, result) val[1].each do |file| import(file) end @@ -2279,8 +2243,8 @@ module_eval(<<'.,.,', 'grammar.ra', 636) end .,., -module_eval(<<'.,.,', 'grammar.ra', 646) - def _reduce_179(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 654) + def _reduce_180(val, _values, result) @lexer.commentpop result = Puppet::Parser::AST::Definition.new(classname(val[1]), ast_context(true).merge(:arguments => val[2], :code => val[4], @@ -2293,8 +2257,8 @@ module_eval(<<'.,.,', 'grammar.ra', 646) end .,., -module_eval(<<'.,.,', 'grammar.ra', 654) - def _reduce_180(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 662) + def _reduce_181(val, _values, result) @lexer.commentpop result = Puppet::Parser::AST::Definition.new(classname(val[1]), ast_context(true).merge(:arguments => val[2], :line => val[0][:line])) @@ -2304,12 +2268,11 @@ module_eval(<<'.,.,', 'grammar.ra', 654) end .,., -module_eval(<<'.,.,', 'grammar.ra', 662) - def _reduce_181(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 670) + def _reduce_182(val, _values, result) @lexer.commentpop # Our class gets defined in the parent namespace, not our own. @lexer.namepop - val[5].is_a_namespace = true 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])) @@ -2318,8 +2281,8 @@ module_eval(<<'.,.,', 'grammar.ra', 662) end .,., -module_eval(<<'.,.,', 'grammar.ra', 670) - def _reduce_182(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 677) + def _reduce_183(val, _values, result) @lexer.commentpop # Our class gets defined in the parent namespace, not our own. @lexer.namepop @@ -2331,8 +2294,8 @@ module_eval(<<'.,.,', 'grammar.ra', 670) end .,., -module_eval(<<'.,.,', 'grammar.ra', 679) - def _reduce_183(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 686) + def _reduce_184(val, _values, result) @lexer.commentpop result = Puppet::Parser::AST::Node.new(val[1], ast_context(true).merge(:parent => val[2], :code => val[4], @@ -2342,8 +2305,8 @@ module_eval(<<'.,.,', 'grammar.ra', 679) end .,., -module_eval(<<'.,.,', 'grammar.ra', 684) - def _reduce_184(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 691) + def _reduce_185(val, _values, result) @lexer.commentpop result = Puppet::Parser::AST::Node.new(val[1], ast_context(true).merge(:parent => val[2], :line => val[0][:line])) @@ -2351,44 +2314,44 @@ module_eval(<<'.,.,', 'grammar.ra', 684) end .,., -module_eval(<<'.,.,', 'grammar.ra', 688) - def _reduce_185(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 695) + def _reduce_186(val, _values, result) result = val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 690) - def _reduce_186(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 697) + def _reduce_187(val, _values, result) result = val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 691) - def _reduce_187(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 698) + def _reduce_188(val, _values, result) result = val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 692) - def _reduce_188(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 699) + def _reduce_189(val, _values, result) result = "class" result end .,., -module_eval(<<'.,.,', 'grammar.ra', 697) - def _reduce_189(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 704) + def _reduce_190(val, _values, result) result = [result] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 700) - def _reduce_190(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 707) + def _reduce_191(val, _values, result) result = val[0] result << val[2] @@ -2396,65 +2359,65 @@ module_eval(<<'.,.,', 'grammar.ra', 700) end .,., -module_eval(<<'.,.,', 'grammar.ra', 705) - def _reduce_191(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 712) + def _reduce_192(val, _values, result) result = ast AST::HostName, :value => val[0] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 708) - def _reduce_192(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 715) + def _reduce_193(val, _values, result) result = val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 709) - def _reduce_193(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 716) + def _reduce_194(val, _values, result) result = val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 710) - def _reduce_194(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 717) + def _reduce_195(val, _values, result) result = val[0][:value] result end .,., -# reduce 195 omitted +# reduce 196 omitted -module_eval(<<'.,.,', 'grammar.ra', 714) - def _reduce_196(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 721) + def _reduce_197(val, _values, result) result = nil result end .,., -module_eval(<<'.,.,', 'grammar.ra', 718) - def _reduce_197(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 725) + def _reduce_198(val, _values, result) result = ast AST::ASTArray, :children => [] result end .,., -# reduce 198 omitted +# reduce 199 omitted -module_eval(<<'.,.,', 'grammar.ra', 723) - def _reduce_199(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 730) + def _reduce_200(val, _values, result) result = nil result end .,., -module_eval(<<'.,.,', 'grammar.ra', 726) - def _reduce_200(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 733) + def _reduce_201(val, _values, result) result = val[1] result = [result] unless result[0].is_a?(Array) @@ -2462,10 +2425,10 @@ module_eval(<<'.,.,', 'grammar.ra', 726) end .,., -# reduce 201 omitted +# reduce 202 omitted -module_eval(<<'.,.,', 'grammar.ra', 732) - def _reduce_202(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 739) + def _reduce_203(val, _values, result) result = val[0] result = [result] unless result[0].is_a?(Array) result << val[2] @@ -2474,8 +2437,8 @@ module_eval(<<'.,.,', 'grammar.ra', 732) end .,., -module_eval(<<'.,.,', 'grammar.ra', 738) - def _reduce_203(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 745) + def _reduce_204(val, _values, result) Puppet.warning addcontext("Deprecation notice: must now include '$' in prototype") result = [val[0][:value], val[2]] @@ -2483,8 +2446,8 @@ module_eval(<<'.,.,', 'grammar.ra', 738) end .,., -module_eval(<<'.,.,', 'grammar.ra', 742) - def _reduce_204(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 749) + def _reduce_205(val, _values, result) Puppet.warning addcontext("Deprecation notice: must now include '$' in prototype") result = [val[0][:value]] @@ -2492,56 +2455,56 @@ module_eval(<<'.,.,', 'grammar.ra', 742) end .,., -module_eval(<<'.,.,', 'grammar.ra', 745) - def _reduce_205(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 752) + def _reduce_206(val, _values, result) result = [val[0][:value], val[2]] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 747) - def _reduce_206(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 754) + def _reduce_207(val, _values, result) result = [val[0][:value]] result end .,., -# reduce 207 omitted +# reduce 208 omitted -module_eval(<<'.,.,', 'grammar.ra', 752) - def _reduce_208(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 759) + def _reduce_209(val, _values, result) result = val[1] result end .,., -# reduce 209 omitted +# reduce 210 omitted -module_eval(<<'.,.,', 'grammar.ra', 757) - def _reduce_210(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 764) + def _reduce_211(val, _values, result) result = val[1] result end .,., -# reduce 211 omitted - # reduce 212 omitted -module_eval(<<'.,.,', 'grammar.ra', 763) - def _reduce_213(val, _values, result) +# reduce 213 omitted + +module_eval(<<'.,.,', 'grammar.ra', 770) + def _reduce_214(val, _values, result) result = ast AST::Variable, :value => val[0][:value], :line => val[0][:line] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 767) - def _reduce_214(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 774) + def _reduce_215(val, _values, result) if val[1].instance_of?(AST::ASTArray) result = val[1] else @@ -2552,8 +2515,8 @@ module_eval(<<'.,.,', 'grammar.ra', 767) end .,., -module_eval(<<'.,.,', 'grammar.ra', 774) - def _reduce_215(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 781) + def _reduce_216(val, _values, result) if val[1].instance_of?(AST::ASTArray) result = val[1] else @@ -2564,37 +2527,37 @@ module_eval(<<'.,.,', 'grammar.ra', 774) end .,., -module_eval(<<'.,.,', 'grammar.ra', 780) - def _reduce_216(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 787) + def _reduce_217(val, _values, result) result = ast AST::ASTArray result end .,., -# reduce 217 omitted - # reduce 218 omitted # reduce 219 omitted -module_eval(<<'.,.,', 'grammar.ra', 787) - def _reduce_220(val, _values, result) +# reduce 220 omitted + +module_eval(<<'.,.,', 'grammar.ra', 794) + def _reduce_221(val, _values, result) result = nil result end .,., -module_eval(<<'.,.,', 'grammar.ra', 790) - def _reduce_221(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 797) + def _reduce_222(val, _values, result) result = ast AST::Regex, :value => val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 794) - def _reduce_222(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 801) + def _reduce_223(val, _values, result) if val[1].instance_of?(AST::ASTHash) result = val[1] else @@ -2605,8 +2568,8 @@ module_eval(<<'.,.,', 'grammar.ra', 794) end .,., -module_eval(<<'.,.,', 'grammar.ra', 801) - def _reduce_223(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 808) + def _reduce_224(val, _values, result) if val[1].instance_of?(AST::ASTHash) result = val[1] else @@ -2617,18 +2580,18 @@ module_eval(<<'.,.,', 'grammar.ra', 801) end .,., -module_eval(<<'.,.,', 'grammar.ra', 807) - def _reduce_224(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 814) + def _reduce_225(val, _values, result) result = ast AST::ASTHash result end .,., -# reduce 225 omitted +# reduce 226 omitted -module_eval(<<'.,.,', 'grammar.ra', 812) - def _reduce_226(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 819) + def _reduce_227(val, _values, result) if val[0].instance_of?(AST::ASTHash) result = val[0].merge(val[2]) else @@ -2640,40 +2603,40 @@ module_eval(<<'.,.,', 'grammar.ra', 812) end .,., -module_eval(<<'.,.,', 'grammar.ra', 821) - def _reduce_227(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 828) + def _reduce_228(val, _values, result) result = ast AST::ASTHash, { :value => { val[0] => val[2] } } result end .,., -module_eval(<<'.,.,', 'grammar.ra', 824) - def _reduce_228(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 831) + def _reduce_229(val, _values, result) result = val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 825) - def _reduce_229(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 832) + def _reduce_230(val, _values, result) result = val[0] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 828) - def _reduce_230(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 835) + def _reduce_231(val, _values, result) result = ast AST::HashOrArrayAccess, :variable => val[0][:value], :key => val[2] result end .,., -# reduce 231 omitted +# reduce 232 omitted -module_eval(<<'.,.,', 'grammar.ra', 833) - def _reduce_232(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 840) + def _reduce_233(val, _values, result) result = ast AST::HashOrArrayAccess, :variable => val[0], :key => val[2] result -- cgit From 6b278503021c4404904f56ced6995d0fbfa5b8fe Mon Sep 17 00:00:00 2001 From: Paul Berry Date: Thu, 2 Sep 2010 18:10:37 -0700 Subject: [#4657] Customer-supplied .rb files are not compatible with multiple environments or staleness check Changed the resource type API to create AST objects rather than directly instantiating resource types. This allows the same code paths to be used to handle the results of parsing both .pp and .rb files. This makes .rb files work properly in multiple environments, because the types are now instantiated by code that is aware of which environment the compilation is happening in. It also reduces the risk of future changes breaking .rb file support. Also, switched to using "instance_eval" rather than "require" to evaluate the contents of the .rb file. This ensures that if the file has to be recompiled (because it became stale), it will actually get re-evaluated. As a side benefit, ResourceTypeAPI is now a class rather than a mixin to Object, so its methods do not pollute the global namespace. To reduce the risk of customers coming to rely on implementation details of the resource type API, changed its methods to return nil, and removed methods from it that were misleadingly labeled as "private". --- lib/puppet/dsl.rb | 4 ---- lib/puppet/dsl/resource_type_api.rb | 48 ++++++++++++++++--------------------- lib/puppet/parser/ast/definition.rb | 7 ++++-- lib/puppet/parser/ast/hostclass.rb | 7 ++++-- lib/puppet/parser/ast/node.rb | 7 ++++-- lib/puppet/parser/parser_support.rb | 11 ++++++--- 6 files changed, 44 insertions(+), 40 deletions(-) (limited to 'lib') diff --git a/lib/puppet/dsl.rb b/lib/puppet/dsl.rb index abdb78f67..97a310436 100644 --- a/lib/puppet/dsl.rb +++ b/lib/puppet/dsl.rb @@ -5,7 +5,3 @@ end require 'puppet/dsl/resource_type_api' require 'puppet/dsl/resource_api' - -class Object - include Puppet::DSL::ResourceTypeAPI -end diff --git a/lib/puppet/dsl/resource_type_api.rb b/lib/puppet/dsl/resource_type_api.rb index 487aab99d..8810d5368 100644 --- a/lib/puppet/dsl/resource_type_api.rb +++ b/lib/puppet/dsl/resource_type_api.rb @@ -1,34 +1,15 @@ require 'puppet/resource/type' -module Puppet::DSL::ResourceTypeAPI - def define(name, *args, &block) - result = mk_resource_type(:definition, name, Hash.new, block) - result.set_arguments(munge_type_arguments(args)) - result - end - - def hostclass(name, options = {}, &block) - mk_resource_type(:hostclass, name, options, block) - end - - def node(name, options = {}, &block) - mk_resource_type(:node, name, options, block) - end - - private - - def mk_resource_type(type, name, options, code) - klass = Puppet::Resource::Type.new(type, name, options) - - klass.ruby_code = code if code - - Puppet::Node::Environment.new.known_resource_types.add klass - - klass +# Type of the objects inside of which pure ruby manifest files are +# executed. Provides methods for creating defines, hostclasses, and +# nodes. +class Puppet::DSL::ResourceTypeAPI + def initialize + @__created_ast_objects__ = [] end - def munge_type_arguments(args) - args.inject([]) do |result, item| + def define(name, *args, &block) + args = args.inject([]) do |result, item| if item.is_a?(Hash) item.each { |p, v| result << [p, v] } else @@ -36,5 +17,18 @@ module Puppet::DSL::ResourceTypeAPI end result end + @__created_ast_objects__.push Puppet::Parser::AST::Definition.new(name, {:arguments => args}, &block) + nil + end + + def hostclass(name, options = {}, &block) + @__created_ast_objects__.push Puppet::Parser::AST::Hostclass.new(name, options, &block) + nil + end + + def node(name, options = {}, &block) + name = [name] unless name.is_a?(Array) + @__created_ast_objects__.push Puppet::Parser::AST::Node.new(name, options, &block) + nil end end diff --git a/lib/puppet/parser/ast/definition.rb b/lib/puppet/parser/ast/definition.rb index 09f52b519..985f8f286 100644 --- a/lib/puppet/parser/ast/definition.rb +++ b/lib/puppet/parser/ast/definition.rb @@ -1,12 +1,15 @@ require 'puppet/parser/ast/top_level_construct' class Puppet::Parser::AST::Definition < Puppet::Parser::AST::TopLevelConstruct - def initialize(name, context = {}) + def initialize(name, context = {}, &ruby_code) @name = name @context = context + @ruby_code = ruby_code end def instantiate(modname) - return [Puppet::Resource::Type.new(:definition, @name, @context.merge(:module_name => modname))] + new_definition = Puppet::Resource::Type.new(:definition, @name, @context.merge(:module_name => modname)) + new_definition.ruby_code = @ruby_code if @ruby_code + [new_definition] end end diff --git a/lib/puppet/parser/ast/hostclass.rb b/lib/puppet/parser/ast/hostclass.rb index d539e4deb..cab5e4a24 100644 --- a/lib/puppet/parser/ast/hostclass.rb +++ b/lib/puppet/parser/ast/hostclass.rb @@ -3,13 +3,16 @@ require 'puppet/parser/ast/top_level_construct' class Puppet::Parser::AST::Hostclass < Puppet::Parser::AST::TopLevelConstruct attr_accessor :name, :context - def initialize(name, context = {}) + def initialize(name, context = {}, &ruby_code) @context = context @name = name + @ruby_code = ruby_code end def instantiate(modname) - all_types = [Puppet::Resource::Type.new(:hostclass, @name, @context.merge(:module_name => modname))] + new_class = Puppet::Resource::Type.new(:hostclass, @name, @context.merge(:module_name => modname)) + new_class.ruby_code = @ruby_code if @ruby_code + all_types = [new_class] if code code.each do |nested_ast_node| if nested_ast_node.respond_to? :instantiate diff --git a/lib/puppet/parser/ast/node.rb b/lib/puppet/parser/ast/node.rb index c19a24ce0..9767399f7 100644 --- a/lib/puppet/parser/ast/node.rb +++ b/lib/puppet/parser/ast/node.rb @@ -3,15 +3,18 @@ require 'puppet/parser/ast/top_level_construct' class Puppet::Parser::AST::Node < Puppet::Parser::AST::TopLevelConstruct attr_accessor :names - def initialize(names, context = {}) + def initialize(names, context = {}, &ruby_code) raise ArgumentError, "names should be an array" unless names.is_a? Array @names = names @context = context + @ruby_code = ruby_code end def instantiate(modname) @names.collect do |name| - Puppet::Resource::Type.new(:node, name, @context.merge(:module_name => modname)) + new_node = Puppet::Resource::Type.new(:node, name, @context.merge(:module_name => modname)) + new_node.ruby_code = @ruby_code if @ruby_code + new_node end end end diff --git a/lib/puppet/parser/parser_support.rb b/lib/puppet/parser/parser_support.rb index 859897a16..a9df33f8b 100644 --- a/lib/puppet/parser/parser_support.rb +++ b/lib/puppet/parser/parser_support.rb @@ -155,8 +155,7 @@ class Puppet::Parser::Parser # how should I do error handling here? def parse(string = nil) if self.file =~ /\.rb$/ - parse_ruby_file - main = nil + main = parse_ruby_file else self.string = string if string begin @@ -196,7 +195,13 @@ class Puppet::Parser::Parser end def parse_ruby_file - require self.file + # Execute the contents of the file inside its own "main" object so + # that it can call methods in the resource type API. + main_object = Puppet::DSL::ResourceTypeAPI.new + main_object.instance_eval(File.read(self.file)) + + # Then extract any types that were created. + Puppet::Parser::AST::ASTArray.new :children => main_object.instance_eval { @__created_ast_objects__ } end def string=(string) -- cgit From ce9bf1edcaac4901de6e0a7da413d1742d216eb0 Mon Sep 17 00:00:00 2001 From: Paul Berry Date: Tue, 7 Sep 2010 18:01:42 -0700 Subject: Modified the error message that is generated when a class, definition, or node occurs in a conditional construct so that it contains the proper line number. --- lib/puppet/parser/ast/definition.rb | 2 + lib/puppet/parser/ast/node.rb | 2 +- lib/puppet/parser/grammar.ra | 3 +- lib/puppet/parser/parser.rb | 273 ++++++++++++++++++------------------ lib/puppet/parser/parser_support.rb | 6 +- 5 files changed, 145 insertions(+), 141 deletions(-) (limited to 'lib') diff --git a/lib/puppet/parser/ast/definition.rb b/lib/puppet/parser/ast/definition.rb index 09f52b519..287845ade 100644 --- a/lib/puppet/parser/ast/definition.rb +++ b/lib/puppet/parser/ast/definition.rb @@ -1,6 +1,8 @@ require 'puppet/parser/ast/top_level_construct' class Puppet::Parser::AST::Definition < Puppet::Parser::AST::TopLevelConstruct + attr_accessor :context + def initialize(name, context = {}) @name = name @context = context diff --git a/lib/puppet/parser/ast/node.rb b/lib/puppet/parser/ast/node.rb index c19a24ce0..4951a6365 100644 --- a/lib/puppet/parser/ast/node.rb +++ b/lib/puppet/parser/ast/node.rb @@ -1,7 +1,7 @@ require 'puppet/parser/ast/top_level_construct' class Puppet::Parser::AST::Node < Puppet::Parser::AST::TopLevelConstruct - attr_accessor :names + attr_accessor :names, :context def initialize(names, context = {}) raise ArgumentError, "names should be an array" unless names.is_a? Array diff --git a/lib/puppet/parser/grammar.ra b/lib/puppet/parser/grammar.ra index 9377c0b02..3d77d2db8 100644 --- a/lib/puppet/parser/grammar.ra +++ b/lib/puppet/parser/grammar.ra @@ -44,7 +44,8 @@ program: statements_and_declarations 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" + 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] diff --git a/lib/puppet/parser/parser.rb b/lib/puppet/parser/parser.rb index 868716e0d..5b24d8434 100644 --- a/lib/puppet/parser/parser.rb +++ b/lib/puppet/parser/parser.rb @@ -21,7 +21,7 @@ module Puppet module Parser class Parser < Racc::Parser -module_eval(<<'...end grammar.ra/module_eval...', 'grammar.ra', 858) +module_eval(<<'...end grammar.ra/module_eval...', 'grammar.ra', 859) # It got too annoying having code in a file that needs to be compiled. require 'puppet/parser/parser_support' @@ -1152,7 +1152,8 @@ module_eval(<<'.,.,', 'grammar.ra', 44) def _reduce_5(val, _values, result) 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" + 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] @@ -1189,7 +1190,7 @@ module_eval(<<'.,.,', 'grammar.ra', 44) # reduce 19 omitted -module_eval(<<'.,.,', 'grammar.ra', 69) +module_eval(<<'.,.,', 'grammar.ra', 70) def _reduce_20(val, _values, result) result = AST::Relationship.new(val[0], val[2], val[1][:value], ast_context) @@ -1197,7 +1198,7 @@ module_eval(<<'.,.,', 'grammar.ra', 69) end .,., -module_eval(<<'.,.,', 'grammar.ra', 72) +module_eval(<<'.,.,', 'grammar.ra', 73) def _reduce_21(val, _values, result) result = AST::Relationship.new(val[0], val[2], val[1][:value], ast_context) @@ -1219,7 +1220,7 @@ module_eval(<<'.,.,', 'grammar.ra', 72) # reduce 28 omitted -module_eval(<<'.,.,', 'grammar.ra', 80) +module_eval(<<'.,.,', 'grammar.ra', 81) def _reduce_29(val, _values, result) args = aryfy(val[2]) result = ast AST::Function, @@ -1232,7 +1233,7 @@ module_eval(<<'.,.,', 'grammar.ra', 80) end .,., -module_eval(<<'.,.,', 'grammar.ra', 88) +module_eval(<<'.,.,', 'grammar.ra', 89) def _reduce_30(val, _values, result) args = aryfy(val[2]) result = ast AST::Function, @@ -1245,7 +1246,7 @@ module_eval(<<'.,.,', 'grammar.ra', 88) end .,., -module_eval(<<'.,.,', 'grammar.ra', 95) +module_eval(<<'.,.,', 'grammar.ra', 96) def _reduce_31(val, _values, result) result = ast AST::Function, :name => val[0][:value], @@ -1257,7 +1258,7 @@ module_eval(<<'.,.,', 'grammar.ra', 95) end .,., -module_eval(<<'.,.,', 'grammar.ra', 102) +module_eval(<<'.,.,', 'grammar.ra', 103) def _reduce_32(val, _values, result) args = aryfy(val[1]) result = ast AST::Function, @@ -1274,7 +1275,7 @@ module_eval(<<'.,.,', 'grammar.ra', 102) # reduce 34 omitted -module_eval(<<'.,.,', 'grammar.ra', 113) +module_eval(<<'.,.,', 'grammar.ra', 114) def _reduce_35(val, _values, result) result = aryfy(val[0], val[2]) result.line = @lexer.line @@ -1284,7 +1285,7 @@ module_eval(<<'.,.,', 'grammar.ra', 113) end .,., -module_eval(<<'.,.,', 'grammar.ra', 118) +module_eval(<<'.,.,', 'grammar.ra', 119) def _reduce_36(val, _values, result) unless val[0].is_a?(AST::ASTArray) val[0] = aryfy(val[0]) @@ -1314,7 +1315,7 @@ module_eval(<<'.,.,', 'grammar.ra', 118) # reduce 44 omitted -module_eval(<<'.,.,', 'grammar.ra', 138) +module_eval(<<'.,.,', 'grammar.ra', 139) def _reduce_45(val, _values, result) result = ast AST::Name, :value => val[0][:value] @@ -1322,7 +1323,7 @@ module_eval(<<'.,.,', 'grammar.ra', 138) end .,., -module_eval(<<'.,.,', 'grammar.ra', 142) +module_eval(<<'.,.,', 'grammar.ra', 143) def _reduce_46(val, _values, result) @lexer.commentpop array = val[2] @@ -1347,7 +1348,7 @@ module_eval(<<'.,.,', 'grammar.ra', 142) end .,., -module_eval(<<'.,.,', 'grammar.ra', 161) +module_eval(<<'.,.,', 'grammar.ra', 162) def _reduce_47(val, _values, result) # This is a deprecated syntax. error "All resource specifications require names" @@ -1356,7 +1357,7 @@ module_eval(<<'.,.,', 'grammar.ra', 161) end .,., -module_eval(<<'.,.,', 'grammar.ra', 164) +module_eval(<<'.,.,', 'grammar.ra', 165) def _reduce_48(val, _values, result) # a defaults setting for a type @lexer.commentpop @@ -1366,7 +1367,7 @@ module_eval(<<'.,.,', 'grammar.ra', 164) end .,., -module_eval(<<'.,.,', 'grammar.ra', 171) +module_eval(<<'.,.,', 'grammar.ra', 172) def _reduce_49(val, _values, result) @lexer.commentpop result = ast AST::ResourceOverride, :object => val[0], :parameters => val[2] @@ -1375,7 +1376,7 @@ module_eval(<<'.,.,', 'grammar.ra', 171) end .,., -module_eval(<<'.,.,', 'grammar.ra', 178) +module_eval(<<'.,.,', 'grammar.ra', 179) def _reduce_50(val, _values, result) type = val[0] @@ -1402,21 +1403,21 @@ module_eval(<<'.,.,', 'grammar.ra', 178) end .,., -module_eval(<<'.,.,', 'grammar.ra', 200) +module_eval(<<'.,.,', 'grammar.ra', 201) def _reduce_51(val, _values, result) result = :virtual result end .,., -module_eval(<<'.,.,', 'grammar.ra', 201) +module_eval(<<'.,.,', 'grammar.ra', 202) def _reduce_52(val, _values, result) result = :exported result end .,., -module_eval(<<'.,.,', 'grammar.ra', 206) +module_eval(<<'.,.,', 'grammar.ra', 207) def _reduce_53(val, _values, result) @lexer.commentpop Puppet.warning addcontext("Collection names must now be capitalized") if val[0] =~ /^[a-z]/ @@ -1440,7 +1441,7 @@ module_eval(<<'.,.,', 'grammar.ra', 206) end .,., -module_eval(<<'.,.,', 'grammar.ra', 225) +module_eval(<<'.,.,', 'grammar.ra', 226) def _reduce_54(val, _values, result) if val[0] =~ /^[a-z]/ Puppet.warning addcontext("Collection names must now be capitalized") @@ -1464,7 +1465,7 @@ module_eval(<<'.,.,', 'grammar.ra', 225) end .,., -module_eval(<<'.,.,', 'grammar.ra', 246) +module_eval(<<'.,.,', 'grammar.ra', 247) def _reduce_55(val, _values, result) if val[1] result = val[1] @@ -1477,7 +1478,7 @@ module_eval(<<'.,.,', 'grammar.ra', 246) end .,., -module_eval(<<'.,.,', 'grammar.ra', 254) +module_eval(<<'.,.,', 'grammar.ra', 255) def _reduce_56(val, _values, result) if val[1] result = val[1] @@ -1494,7 +1495,7 @@ module_eval(<<'.,.,', 'grammar.ra', 254) # reduce 58 omitted -module_eval(<<'.,.,', 'grammar.ra', 267) +module_eval(<<'.,.,', 'grammar.ra', 268) def _reduce_59(val, _values, result) result = ast AST::CollExpr, :test1 => val[0], :oper => val[1], :test2 => val[2] @@ -1504,7 +1505,7 @@ module_eval(<<'.,.,', 'grammar.ra', 267) # reduce 60 omitted -module_eval(<<'.,.,', 'grammar.ra', 272) +module_eval(<<'.,.,', 'grammar.ra', 273) def _reduce_61(val, _values, result) result = val[1] result.parens = true @@ -1513,21 +1514,21 @@ module_eval(<<'.,.,', 'grammar.ra', 272) end .,., -module_eval(<<'.,.,', 'grammar.ra', 276) +module_eval(<<'.,.,', 'grammar.ra', 277) def _reduce_62(val, _values, result) result=val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 277) +module_eval(<<'.,.,', 'grammar.ra', 278) def _reduce_63(val, _values, result) result=val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 280) +module_eval(<<'.,.,', 'grammar.ra', 281) def _reduce_64(val, _values, result) result = ast AST::CollExpr, :test1 => val[0], :oper => val[1][:value], :test2 => val[2] #result = ast AST::CollExpr @@ -1537,7 +1538,7 @@ module_eval(<<'.,.,', 'grammar.ra', 280) end .,., -module_eval(<<'.,.,', 'grammar.ra', 285) +module_eval(<<'.,.,', 'grammar.ra', 286) def _reduce_65(val, _values, result) result = ast AST::CollExpr, :test1 => val[0], :oper => val[1][:value], :test2 => val[2] #result = ast AST::CollExpr @@ -1551,7 +1552,7 @@ module_eval(<<'.,.,', 'grammar.ra', 285) # reduce 67 omitted -module_eval(<<'.,.,', 'grammar.ra', 294) +module_eval(<<'.,.,', 'grammar.ra', 295) def _reduce_68(val, _values, result) result = ast AST::ResourceInstance, :children => [val[0],val[2]] @@ -1561,7 +1562,7 @@ module_eval(<<'.,.,', 'grammar.ra', 294) # reduce 69 omitted -module_eval(<<'.,.,', 'grammar.ra', 299) +module_eval(<<'.,.,', 'grammar.ra', 300) def _reduce_70(val, _values, result) if val[0].instance_of?(AST::ResourceInstance) result = ast AST::ASTArray, :children => [val[0],val[2]] @@ -1578,7 +1579,7 @@ module_eval(<<'.,.,', 'grammar.ra', 299) # reduce 72 omitted -module_eval(<<'.,.,', 'grammar.ra', 311) +module_eval(<<'.,.,', 'grammar.ra', 312) def _reduce_73(val, _values, result) result = ast AST::Undef, :value => :undef @@ -1586,7 +1587,7 @@ module_eval(<<'.,.,', 'grammar.ra', 311) end .,., -module_eval(<<'.,.,', 'grammar.ra', 315) +module_eval(<<'.,.,', 'grammar.ra', 316) def _reduce_74(val, _values, result) result = ast AST::Name, :value => val[0][:value], :line => val[0][:line] @@ -1594,7 +1595,7 @@ module_eval(<<'.,.,', 'grammar.ra', 315) end .,., -module_eval(<<'.,.,', 'grammar.ra', 319) +module_eval(<<'.,.,', 'grammar.ra', 320) def _reduce_75(val, _values, result) result = ast AST::Type, :value => val[0][:value], :line => val[0][:line] @@ -1616,7 +1617,7 @@ module_eval(<<'.,.,', 'grammar.ra', 319) # reduce 82 omitted -module_eval(<<'.,.,', 'grammar.ra', 331) +module_eval(<<'.,.,', 'grammar.ra', 332) def _reduce_83(val, _values, result) raise Puppet::ParseError, "Cannot assign to variables in other namespaces" if val[0][:value] =~ /::/ # this is distinct from referencing a variable @@ -1627,7 +1628,7 @@ module_eval(<<'.,.,', 'grammar.ra', 331) end .,., -module_eval(<<'.,.,', 'grammar.ra', 337) +module_eval(<<'.,.,', 'grammar.ra', 338) def _reduce_84(val, _values, result) result = ast AST::VarDef, :name => val[0], :value => val[2] @@ -1635,7 +1636,7 @@ module_eval(<<'.,.,', 'grammar.ra', 337) end .,., -module_eval(<<'.,.,', 'grammar.ra', 341) +module_eval(<<'.,.,', 'grammar.ra', 342) def _reduce_85(val, _values, result) 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] @@ -1644,7 +1645,7 @@ module_eval(<<'.,.,', 'grammar.ra', 341) end .,., -module_eval(<<'.,.,', 'grammar.ra', 347) +module_eval(<<'.,.,', 'grammar.ra', 348) def _reduce_86(val, _values, result) result = ast AST::ASTArray @@ -1652,14 +1653,14 @@ module_eval(<<'.,.,', 'grammar.ra', 347) end .,., -module_eval(<<'.,.,', 'grammar.ra', 349) +module_eval(<<'.,.,', 'grammar.ra', 350) def _reduce_87(val, _values, result) result = val[0] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 351) +module_eval(<<'.,.,', 'grammar.ra', 352) def _reduce_88(val, _values, result) if val[0].instance_of?(AST::ASTArray) val[0].push(val[2]) @@ -1672,7 +1673,7 @@ module_eval(<<'.,.,', 'grammar.ra', 351) end .,., -module_eval(<<'.,.,', 'grammar.ra', 360) +module_eval(<<'.,.,', 'grammar.ra', 361) def _reduce_89(val, _values, result) result = ast AST::ResourceParam, :param => val[0][:value], :line => val[0][:line], :value => val[2] @@ -1680,7 +1681,7 @@ module_eval(<<'.,.,', 'grammar.ra', 360) end .,., -module_eval(<<'.,.,', 'grammar.ra', 364) +module_eval(<<'.,.,', 'grammar.ra', 365) def _reduce_90(val, _values, result) result = ast AST::ResourceParam, :param => val[0][:value], :line => val[0][:line], :value => val[2], :add => true @@ -1693,7 +1694,7 @@ module_eval(<<'.,.,', 'grammar.ra', 364) # reduce 92 omitted -module_eval(<<'.,.,', 'grammar.ra', 373) +module_eval(<<'.,.,', 'grammar.ra', 374) def _reduce_93(val, _values, result) result = ast AST::ASTArray @@ -1701,14 +1702,14 @@ module_eval(<<'.,.,', 'grammar.ra', 373) end .,., -module_eval(<<'.,.,', 'grammar.ra', 375) +module_eval(<<'.,.,', 'grammar.ra', 376) def _reduce_94(val, _values, result) result = val[0] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 377) +module_eval(<<'.,.,', 'grammar.ra', 378) def _reduce_95(val, _values, result) if val[0].instance_of?(AST::ASTArray) val[0].push(val[2]) @@ -1723,7 +1724,7 @@ module_eval(<<'.,.,', 'grammar.ra', 377) # reduce 96 omitted -module_eval(<<'.,.,', 'grammar.ra', 387) +module_eval(<<'.,.,', 'grammar.ra', 388) def _reduce_97(val, _values, result) if val[0].instance_of?(AST::ASTArray) result = val[0].push(val[2]) @@ -1771,7 +1772,7 @@ module_eval(<<'.,.,', 'grammar.ra', 387) # reduce 115 omitted -module_eval(<<'.,.,', 'grammar.ra', 416) +module_eval(<<'.,.,', 'grammar.ra', 417) def _reduce_116(val, _values, result) args = aryfy(val[2]) result = ast AST::Function, @@ -1783,7 +1784,7 @@ module_eval(<<'.,.,', 'grammar.ra', 416) end .,., -module_eval(<<'.,.,', 'grammar.ra', 422) +module_eval(<<'.,.,', 'grammar.ra', 423) def _reduce_117(val, _values, result) result = ast AST::Function, :name => val[0][:value], :line => val[0][:line], @@ -1794,42 +1795,42 @@ module_eval(<<'.,.,', 'grammar.ra', 422) end .,., -module_eval(<<'.,.,', 'grammar.ra', 428) +module_eval(<<'.,.,', 'grammar.ra', 429) def _reduce_118(val, _values, result) result = ast AST::String, :value => val[0][:value], :line => val[0][:line] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 429) +module_eval(<<'.,.,', 'grammar.ra', 430) def _reduce_119(val, _values, result) result = ast AST::Concat, :value => [ast(AST::String,val[0])]+val[1], :line => val[0][:line] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 431) +module_eval(<<'.,.,', 'grammar.ra', 432) def _reduce_120(val, _values, result) result = [val[0]] + val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 433) +module_eval(<<'.,.,', 'grammar.ra', 434) def _reduce_121(val, _values, result) result = [ast(AST::String,val[0])] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 434) +module_eval(<<'.,.,', 'grammar.ra', 435) def _reduce_122(val, _values, result) result = [ast(AST::String,val[0])] + val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 437) +module_eval(<<'.,.,', 'grammar.ra', 438) def _reduce_123(val, _values, result) result = ast AST::Boolean, :value => val[0][:value], :line => val[0][:line] @@ -1837,7 +1838,7 @@ module_eval(<<'.,.,', 'grammar.ra', 437) end .,., -module_eval(<<'.,.,', 'grammar.ra', 441) +module_eval(<<'.,.,', 'grammar.ra', 442) def _reduce_124(val, _values, result) 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] @@ -1846,7 +1847,7 @@ module_eval(<<'.,.,', 'grammar.ra', 441) end .,., -module_eval(<<'.,.,', 'grammar.ra', 444) +module_eval(<<'.,.,', 'grammar.ra', 445) def _reduce_125(val, _values, result) result = ast AST::ResourceReference, :type => val[0], :title => val[2] @@ -1854,7 +1855,7 @@ module_eval(<<'.,.,', 'grammar.ra', 444) end .,., -module_eval(<<'.,.,', 'grammar.ra', 448) +module_eval(<<'.,.,', 'grammar.ra', 449) def _reduce_126(val, _values, result) result = val[1] @@ -1862,7 +1863,7 @@ module_eval(<<'.,.,', 'grammar.ra', 448) end .,., -module_eval(<<'.,.,', 'grammar.ra', 452) +module_eval(<<'.,.,', 'grammar.ra', 453) def _reduce_127(val, _values, result) @lexer.commentpop args = { @@ -1878,7 +1879,7 @@ module_eval(<<'.,.,', 'grammar.ra', 452) end .,., -module_eval(<<'.,.,', 'grammar.ra', 463) +module_eval(<<'.,.,', 'grammar.ra', 464) def _reduce_128(val, _values, result) @lexer.commentpop args = { @@ -1896,7 +1897,7 @@ module_eval(<<'.,.,', 'grammar.ra', 463) # reduce 129 omitted -module_eval(<<'.,.,', 'grammar.ra', 476) +module_eval(<<'.,.,', 'grammar.ra', 477) def _reduce_130(val, _values, result) result = ast AST::Else, :statements => val[1] @@ -1904,7 +1905,7 @@ module_eval(<<'.,.,', 'grammar.ra', 476) end .,., -module_eval(<<'.,.,', 'grammar.ra', 479) +module_eval(<<'.,.,', 'grammar.ra', 480) def _reduce_131(val, _values, result) @lexer.commentpop result = ast AST::Else, :statements => val[2] @@ -1913,7 +1914,7 @@ module_eval(<<'.,.,', 'grammar.ra', 479) end .,., -module_eval(<<'.,.,', 'grammar.ra', 483) +module_eval(<<'.,.,', 'grammar.ra', 484) def _reduce_132(val, _values, result) @lexer.commentpop result = ast AST::Else, :statements => ast(AST::Nop) @@ -1924,7 +1925,7 @@ module_eval(<<'.,.,', 'grammar.ra', 483) # reduce 133 omitted -module_eval(<<'.,.,', 'grammar.ra', 501) +module_eval(<<'.,.,', 'grammar.ra', 502) def _reduce_134(val, _values, result) result = ast AST::InOperator, :lval => val[0], :rval => val[2] @@ -1932,7 +1933,7 @@ module_eval(<<'.,.,', 'grammar.ra', 501) end .,., -module_eval(<<'.,.,', 'grammar.ra', 504) +module_eval(<<'.,.,', 'grammar.ra', 505) def _reduce_135(val, _values, result) result = ast AST::MatchOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -1940,7 +1941,7 @@ module_eval(<<'.,.,', 'grammar.ra', 504) end .,., -module_eval(<<'.,.,', 'grammar.ra', 507) +module_eval(<<'.,.,', 'grammar.ra', 508) def _reduce_136(val, _values, result) result = ast AST::MatchOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -1948,7 +1949,7 @@ module_eval(<<'.,.,', 'grammar.ra', 507) end .,., -module_eval(<<'.,.,', 'grammar.ra', 510) +module_eval(<<'.,.,', 'grammar.ra', 511) def _reduce_137(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -1956,7 +1957,7 @@ module_eval(<<'.,.,', 'grammar.ra', 510) end .,., -module_eval(<<'.,.,', 'grammar.ra', 513) +module_eval(<<'.,.,', 'grammar.ra', 514) def _reduce_138(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -1964,7 +1965,7 @@ module_eval(<<'.,.,', 'grammar.ra', 513) end .,., -module_eval(<<'.,.,', 'grammar.ra', 516) +module_eval(<<'.,.,', 'grammar.ra', 517) def _reduce_139(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -1972,7 +1973,7 @@ module_eval(<<'.,.,', 'grammar.ra', 516) end .,., -module_eval(<<'.,.,', 'grammar.ra', 519) +module_eval(<<'.,.,', 'grammar.ra', 520) def _reduce_140(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -1980,7 +1981,7 @@ module_eval(<<'.,.,', 'grammar.ra', 519) end .,., -module_eval(<<'.,.,', 'grammar.ra', 522) +module_eval(<<'.,.,', 'grammar.ra', 523) def _reduce_141(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -1988,7 +1989,7 @@ module_eval(<<'.,.,', 'grammar.ra', 522) end .,., -module_eval(<<'.,.,', 'grammar.ra', 525) +module_eval(<<'.,.,', 'grammar.ra', 526) def _reduce_142(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -1996,7 +1997,7 @@ module_eval(<<'.,.,', 'grammar.ra', 525) end .,., -module_eval(<<'.,.,', 'grammar.ra', 528) +module_eval(<<'.,.,', 'grammar.ra', 529) def _reduce_143(val, _values, result) result = ast AST::Minus, :value => val[1] @@ -2004,7 +2005,7 @@ module_eval(<<'.,.,', 'grammar.ra', 528) end .,., -module_eval(<<'.,.,', 'grammar.ra', 531) +module_eval(<<'.,.,', 'grammar.ra', 532) def _reduce_144(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2012,7 +2013,7 @@ module_eval(<<'.,.,', 'grammar.ra', 531) end .,., -module_eval(<<'.,.,', 'grammar.ra', 534) +module_eval(<<'.,.,', 'grammar.ra', 535) def _reduce_145(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2020,7 +2021,7 @@ module_eval(<<'.,.,', 'grammar.ra', 534) end .,., -module_eval(<<'.,.,', 'grammar.ra', 537) +module_eval(<<'.,.,', 'grammar.ra', 538) def _reduce_146(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2028,7 +2029,7 @@ module_eval(<<'.,.,', 'grammar.ra', 537) end .,., -module_eval(<<'.,.,', 'grammar.ra', 540) +module_eval(<<'.,.,', 'grammar.ra', 541) def _reduce_147(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2036,7 +2037,7 @@ module_eval(<<'.,.,', 'grammar.ra', 540) end .,., -module_eval(<<'.,.,', 'grammar.ra', 543) +module_eval(<<'.,.,', 'grammar.ra', 544) def _reduce_148(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2044,7 +2045,7 @@ module_eval(<<'.,.,', 'grammar.ra', 543) end .,., -module_eval(<<'.,.,', 'grammar.ra', 546) +module_eval(<<'.,.,', 'grammar.ra', 547) def _reduce_149(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2052,7 +2053,7 @@ module_eval(<<'.,.,', 'grammar.ra', 546) end .,., -module_eval(<<'.,.,', 'grammar.ra', 549) +module_eval(<<'.,.,', 'grammar.ra', 550) def _reduce_150(val, _values, result) result = ast AST::Not, :value => val[1] @@ -2060,7 +2061,7 @@ module_eval(<<'.,.,', 'grammar.ra', 549) end .,., -module_eval(<<'.,.,', 'grammar.ra', 552) +module_eval(<<'.,.,', 'grammar.ra', 553) def _reduce_151(val, _values, result) result = ast AST::BooleanOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2068,7 +2069,7 @@ module_eval(<<'.,.,', 'grammar.ra', 552) end .,., -module_eval(<<'.,.,', 'grammar.ra', 555) +module_eval(<<'.,.,', 'grammar.ra', 556) def _reduce_152(val, _values, result) result = ast AST::BooleanOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] @@ -2076,7 +2077,7 @@ module_eval(<<'.,.,', 'grammar.ra', 555) end .,., -module_eval(<<'.,.,', 'grammar.ra', 558) +module_eval(<<'.,.,', 'grammar.ra', 559) def _reduce_153(val, _values, result) result = val[1] @@ -2084,7 +2085,7 @@ module_eval(<<'.,.,', 'grammar.ra', 558) end .,., -module_eval(<<'.,.,', 'grammar.ra', 562) +module_eval(<<'.,.,', 'grammar.ra', 563) def _reduce_154(val, _values, result) @lexer.commentpop options = val[3] @@ -2097,7 +2098,7 @@ module_eval(<<'.,.,', 'grammar.ra', 562) # reduce 155 omitted -module_eval(<<'.,.,', 'grammar.ra', 570) +module_eval(<<'.,.,', 'grammar.ra', 571) def _reduce_156(val, _values, result) if val[0].instance_of?(AST::ASTArray) val[0].push val[1] @@ -2110,7 +2111,7 @@ module_eval(<<'.,.,', 'grammar.ra', 570) end .,., -module_eval(<<'.,.,', 'grammar.ra', 579) +module_eval(<<'.,.,', 'grammar.ra', 580) def _reduce_157(val, _values, result) @lexer.commentpop result = ast AST::CaseOpt, :value => val[0], :statements => val[3] @@ -2119,7 +2120,7 @@ module_eval(<<'.,.,', 'grammar.ra', 579) end .,., -module_eval(<<'.,.,', 'grammar.ra', 582) +module_eval(<<'.,.,', 'grammar.ra', 583) def _reduce_158(val, _values, result) @lexer.commentpop @@ -2136,7 +2137,7 @@ module_eval(<<'.,.,', 'grammar.ra', 582) # reduce 159 omitted -module_eval(<<'.,.,', 'grammar.ra', 594) +module_eval(<<'.,.,', 'grammar.ra', 595) def _reduce_160(val, _values, result) if val[0].instance_of?(AST::ASTArray) val[0].push(val[2]) @@ -2149,7 +2150,7 @@ module_eval(<<'.,.,', 'grammar.ra', 594) end .,., -module_eval(<<'.,.,', 'grammar.ra', 603) +module_eval(<<'.,.,', 'grammar.ra', 604) def _reduce_161(val, _values, result) result = ast AST::Selector, :param => val[0], :values => val[2] @@ -2159,7 +2160,7 @@ module_eval(<<'.,.,', 'grammar.ra', 603) # reduce 162 omitted -module_eval(<<'.,.,', 'grammar.ra', 608) +module_eval(<<'.,.,', 'grammar.ra', 609) def _reduce_163(val, _values, result) @lexer.commentpop result = val[1] @@ -2170,7 +2171,7 @@ module_eval(<<'.,.,', 'grammar.ra', 608) # reduce 164 omitted -module_eval(<<'.,.,', 'grammar.ra', 614) +module_eval(<<'.,.,', 'grammar.ra', 615) def _reduce_165(val, _values, result) if val[0].instance_of?(AST::ASTArray) val[0].push(val[2]) @@ -2183,7 +2184,7 @@ module_eval(<<'.,.,', 'grammar.ra', 614) end .,., -module_eval(<<'.,.,', 'grammar.ra', 623) +module_eval(<<'.,.,', 'grammar.ra', 624) def _reduce_166(val, _values, result) result = ast AST::ResourceParam, :param => val[0], :value => val[2] @@ -2205,7 +2206,7 @@ module_eval(<<'.,.,', 'grammar.ra', 623) # reduce 173 omitted -module_eval(<<'.,.,', 'grammar.ra', 634) +module_eval(<<'.,.,', 'grammar.ra', 635) def _reduce_174(val, _values, result) result = ast AST::Default, :value => val[0][:value], :line => val[0][:line] @@ -2215,7 +2216,7 @@ module_eval(<<'.,.,', 'grammar.ra', 634) # reduce 175 omitted -module_eval(<<'.,.,', 'grammar.ra', 639) +module_eval(<<'.,.,', 'grammar.ra', 640) def _reduce_176(val, _values, result) result = [val[0][:value]] result @@ -2224,14 +2225,14 @@ module_eval(<<'.,.,', 'grammar.ra', 639) # reduce 177 omitted -module_eval(<<'.,.,', 'grammar.ra', 641) +module_eval(<<'.,.,', 'grammar.ra', 642) def _reduce_178(val, _values, result) result = val[0] += val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 644) +module_eval(<<'.,.,', 'grammar.ra', 645) def _reduce_179(val, _values, result) val[1].each do |file| import(file) @@ -2243,7 +2244,7 @@ module_eval(<<'.,.,', 'grammar.ra', 644) end .,., -module_eval(<<'.,.,', 'grammar.ra', 654) +module_eval(<<'.,.,', 'grammar.ra', 655) def _reduce_180(val, _values, result) @lexer.commentpop result = Puppet::Parser::AST::Definition.new(classname(val[1]), @@ -2257,7 +2258,7 @@ module_eval(<<'.,.,', 'grammar.ra', 654) end .,., -module_eval(<<'.,.,', 'grammar.ra', 662) +module_eval(<<'.,.,', 'grammar.ra', 663) def _reduce_181(val, _values, result) @lexer.commentpop result = Puppet::Parser::AST::Definition.new(classname(val[1]), @@ -2268,7 +2269,7 @@ module_eval(<<'.,.,', 'grammar.ra', 662) end .,., -module_eval(<<'.,.,', 'grammar.ra', 670) +module_eval(<<'.,.,', 'grammar.ra', 671) def _reduce_182(val, _values, result) @lexer.commentpop # Our class gets defined in the parent namespace, not our own. @@ -2281,7 +2282,7 @@ module_eval(<<'.,.,', 'grammar.ra', 670) end .,., -module_eval(<<'.,.,', 'grammar.ra', 677) +module_eval(<<'.,.,', 'grammar.ra', 678) def _reduce_183(val, _values, result) @lexer.commentpop # Our class gets defined in the parent namespace, not our own. @@ -2294,7 +2295,7 @@ module_eval(<<'.,.,', 'grammar.ra', 677) end .,., -module_eval(<<'.,.,', 'grammar.ra', 686) +module_eval(<<'.,.,', 'grammar.ra', 687) def _reduce_184(val, _values, result) @lexer.commentpop result = Puppet::Parser::AST::Node.new(val[1], @@ -2305,7 +2306,7 @@ module_eval(<<'.,.,', 'grammar.ra', 686) end .,., -module_eval(<<'.,.,', 'grammar.ra', 691) +module_eval(<<'.,.,', 'grammar.ra', 692) def _reduce_185(val, _values, result) @lexer.commentpop result = Puppet::Parser::AST::Node.new(val[1], ast_context(true).merge(:parent => val[2], :line => val[0][:line])) @@ -2314,35 +2315,35 @@ module_eval(<<'.,.,', 'grammar.ra', 691) end .,., -module_eval(<<'.,.,', 'grammar.ra', 695) +module_eval(<<'.,.,', 'grammar.ra', 696) def _reduce_186(val, _values, result) result = val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 697) +module_eval(<<'.,.,', 'grammar.ra', 698) def _reduce_187(val, _values, result) result = val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 698) +module_eval(<<'.,.,', 'grammar.ra', 699) def _reduce_188(val, _values, result) result = val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 699) +module_eval(<<'.,.,', 'grammar.ra', 700) def _reduce_189(val, _values, result) result = "class" result end .,., -module_eval(<<'.,.,', 'grammar.ra', 704) +module_eval(<<'.,.,', 'grammar.ra', 705) def _reduce_190(val, _values, result) result = [result] @@ -2350,7 +2351,7 @@ module_eval(<<'.,.,', 'grammar.ra', 704) end .,., -module_eval(<<'.,.,', 'grammar.ra', 707) +module_eval(<<'.,.,', 'grammar.ra', 708) def _reduce_191(val, _values, result) result = val[0] result << val[2] @@ -2359,7 +2360,7 @@ module_eval(<<'.,.,', 'grammar.ra', 707) end .,., -module_eval(<<'.,.,', 'grammar.ra', 712) +module_eval(<<'.,.,', 'grammar.ra', 713) def _reduce_192(val, _values, result) result = ast AST::HostName, :value => val[0] @@ -2367,21 +2368,21 @@ module_eval(<<'.,.,', 'grammar.ra', 712) end .,., -module_eval(<<'.,.,', 'grammar.ra', 715) +module_eval(<<'.,.,', 'grammar.ra', 716) def _reduce_193(val, _values, result) result = val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 716) +module_eval(<<'.,.,', 'grammar.ra', 717) def _reduce_194(val, _values, result) result = val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 717) +module_eval(<<'.,.,', 'grammar.ra', 718) def _reduce_195(val, _values, result) result = val[0][:value] result @@ -2390,7 +2391,7 @@ module_eval(<<'.,.,', 'grammar.ra', 717) # reduce 196 omitted -module_eval(<<'.,.,', 'grammar.ra', 721) +module_eval(<<'.,.,', 'grammar.ra', 722) def _reduce_197(val, _values, result) result = nil @@ -2398,7 +2399,7 @@ module_eval(<<'.,.,', 'grammar.ra', 721) end .,., -module_eval(<<'.,.,', 'grammar.ra', 725) +module_eval(<<'.,.,', 'grammar.ra', 726) def _reduce_198(val, _values, result) result = ast AST::ASTArray, :children => [] @@ -2408,7 +2409,7 @@ module_eval(<<'.,.,', 'grammar.ra', 725) # reduce 199 omitted -module_eval(<<'.,.,', 'grammar.ra', 730) +module_eval(<<'.,.,', 'grammar.ra', 731) def _reduce_200(val, _values, result) result = nil @@ -2416,7 +2417,7 @@ module_eval(<<'.,.,', 'grammar.ra', 730) end .,., -module_eval(<<'.,.,', 'grammar.ra', 733) +module_eval(<<'.,.,', 'grammar.ra', 734) def _reduce_201(val, _values, result) result = val[1] result = [result] unless result[0].is_a?(Array) @@ -2427,7 +2428,7 @@ module_eval(<<'.,.,', 'grammar.ra', 733) # reduce 202 omitted -module_eval(<<'.,.,', 'grammar.ra', 739) +module_eval(<<'.,.,', 'grammar.ra', 740) def _reduce_203(val, _values, result) result = val[0] result = [result] unless result[0].is_a?(Array) @@ -2437,7 +2438,7 @@ module_eval(<<'.,.,', 'grammar.ra', 739) end .,., -module_eval(<<'.,.,', 'grammar.ra', 745) +module_eval(<<'.,.,', 'grammar.ra', 746) def _reduce_204(val, _values, result) Puppet.warning addcontext("Deprecation notice: must now include '$' in prototype") result = [val[0][:value], val[2]] @@ -2446,7 +2447,7 @@ module_eval(<<'.,.,', 'grammar.ra', 745) end .,., -module_eval(<<'.,.,', 'grammar.ra', 749) +module_eval(<<'.,.,', 'grammar.ra', 750) def _reduce_205(val, _values, result) Puppet.warning addcontext("Deprecation notice: must now include '$' in prototype") result = [val[0][:value]] @@ -2455,7 +2456,7 @@ module_eval(<<'.,.,', 'grammar.ra', 749) end .,., -module_eval(<<'.,.,', 'grammar.ra', 752) +module_eval(<<'.,.,', 'grammar.ra', 753) def _reduce_206(val, _values, result) result = [val[0][:value], val[2]] @@ -2463,7 +2464,7 @@ module_eval(<<'.,.,', 'grammar.ra', 752) end .,., -module_eval(<<'.,.,', 'grammar.ra', 754) +module_eval(<<'.,.,', 'grammar.ra', 755) def _reduce_207(val, _values, result) result = [val[0][:value]] @@ -2473,7 +2474,7 @@ module_eval(<<'.,.,', 'grammar.ra', 754) # reduce 208 omitted -module_eval(<<'.,.,', 'grammar.ra', 759) +module_eval(<<'.,.,', 'grammar.ra', 760) def _reduce_209(val, _values, result) result = val[1] @@ -2483,7 +2484,7 @@ module_eval(<<'.,.,', 'grammar.ra', 759) # reduce 210 omitted -module_eval(<<'.,.,', 'grammar.ra', 764) +module_eval(<<'.,.,', 'grammar.ra', 765) def _reduce_211(val, _values, result) result = val[1] @@ -2495,7 +2496,7 @@ module_eval(<<'.,.,', 'grammar.ra', 764) # reduce 213 omitted -module_eval(<<'.,.,', 'grammar.ra', 770) +module_eval(<<'.,.,', 'grammar.ra', 771) def _reduce_214(val, _values, result) result = ast AST::Variable, :value => val[0][:value], :line => val[0][:line] @@ -2503,7 +2504,7 @@ module_eval(<<'.,.,', 'grammar.ra', 770) end .,., -module_eval(<<'.,.,', 'grammar.ra', 774) +module_eval(<<'.,.,', 'grammar.ra', 775) def _reduce_215(val, _values, result) if val[1].instance_of?(AST::ASTArray) result = val[1] @@ -2515,7 +2516,7 @@ module_eval(<<'.,.,', 'grammar.ra', 774) end .,., -module_eval(<<'.,.,', 'grammar.ra', 781) +module_eval(<<'.,.,', 'grammar.ra', 782) def _reduce_216(val, _values, result) if val[1].instance_of?(AST::ASTArray) result = val[1] @@ -2527,7 +2528,7 @@ module_eval(<<'.,.,', 'grammar.ra', 781) end .,., -module_eval(<<'.,.,', 'grammar.ra', 787) +module_eval(<<'.,.,', 'grammar.ra', 788) def _reduce_217(val, _values, result) result = ast AST::ASTArray @@ -2541,14 +2542,14 @@ module_eval(<<'.,.,', 'grammar.ra', 787) # reduce 220 omitted -module_eval(<<'.,.,', 'grammar.ra', 794) +module_eval(<<'.,.,', 'grammar.ra', 795) def _reduce_221(val, _values, result) result = nil result end .,., -module_eval(<<'.,.,', 'grammar.ra', 797) +module_eval(<<'.,.,', 'grammar.ra', 798) def _reduce_222(val, _values, result) result = ast AST::Regex, :value => val[0][:value] @@ -2556,7 +2557,7 @@ module_eval(<<'.,.,', 'grammar.ra', 797) end .,., -module_eval(<<'.,.,', 'grammar.ra', 801) +module_eval(<<'.,.,', 'grammar.ra', 802) def _reduce_223(val, _values, result) if val[1].instance_of?(AST::ASTHash) result = val[1] @@ -2568,7 +2569,7 @@ module_eval(<<'.,.,', 'grammar.ra', 801) end .,., -module_eval(<<'.,.,', 'grammar.ra', 808) +module_eval(<<'.,.,', 'grammar.ra', 809) def _reduce_224(val, _values, result) if val[1].instance_of?(AST::ASTHash) result = val[1] @@ -2580,7 +2581,7 @@ module_eval(<<'.,.,', 'grammar.ra', 808) end .,., -module_eval(<<'.,.,', 'grammar.ra', 814) +module_eval(<<'.,.,', 'grammar.ra', 815) def _reduce_225(val, _values, result) result = ast AST::ASTHash @@ -2590,7 +2591,7 @@ module_eval(<<'.,.,', 'grammar.ra', 814) # reduce 226 omitted -module_eval(<<'.,.,', 'grammar.ra', 819) +module_eval(<<'.,.,', 'grammar.ra', 820) def _reduce_227(val, _values, result) if val[0].instance_of?(AST::ASTHash) result = val[0].merge(val[2]) @@ -2603,7 +2604,7 @@ module_eval(<<'.,.,', 'grammar.ra', 819) end .,., -module_eval(<<'.,.,', 'grammar.ra', 828) +module_eval(<<'.,.,', 'grammar.ra', 829) def _reduce_228(val, _values, result) result = ast AST::ASTHash, { :value => { val[0] => val[2] } } @@ -2611,21 +2612,21 @@ module_eval(<<'.,.,', 'grammar.ra', 828) end .,., -module_eval(<<'.,.,', 'grammar.ra', 831) +module_eval(<<'.,.,', 'grammar.ra', 832) def _reduce_229(val, _values, result) result = val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 832) +module_eval(<<'.,.,', 'grammar.ra', 833) def _reduce_230(val, _values, result) result = val[0] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 835) +module_eval(<<'.,.,', 'grammar.ra', 836) def _reduce_231(val, _values, result) result = ast AST::HashOrArrayAccess, :variable => val[0][:value], :key => val[2] @@ -2635,7 +2636,7 @@ module_eval(<<'.,.,', 'grammar.ra', 835) # reduce 232 omitted -module_eval(<<'.,.,', 'grammar.ra', 840) +module_eval(<<'.,.,', 'grammar.ra', 841) def _reduce_233(val, _values, result) result = ast AST::HashOrArrayAccess, :variable => val[0], :key => val[2] diff --git a/lib/puppet/parser/parser_support.rb b/lib/puppet/parser/parser_support.rb index 859897a16..2b2571d87 100644 --- a/lib/puppet/parser/parser_support.rb +++ b/lib/puppet/parser/parser_support.rb @@ -68,13 +68,13 @@ class Puppet::Parser::Parser end # Raise a Parse error. - def error(message) + def error(message, options = {}) if brace = @lexer.expected message += "; expected '%s'" end except = Puppet::ParseError.new(message) - except.line = @lexer.line - except.file = @lexer.file if @lexer.file + except.line = options[:line] || @lexer.line + except.file = options[:file] || @lexer.file raise except end -- cgit From 6dd1930ff66f6e89ff3d7edba9cc20126d9cd9a3 Mon Sep 17 00:00:00 2001 From: Jesse Wolfe Date: Mon, 4 Oct 2010 14:01:49 -0700 Subject: Fix test failures that fixing #4726 exposed. The patch for #4726 causes old unit tests of the rrd reporting infrastructure to run on my machine. These tests were calling the old report api, which does not succeed. Also, the rrd settings had unintentionally been moved out of the :metrics section, making it possible that the rrd report directory would fail to get created during testing. --- lib/puppet/defaults.rb | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) (limited to 'lib') diff --git a/lib/puppet/defaults.rb b/lib/puppet/defaults.rb index 972e9e66c..ab127602b 100644 --- a/lib/puppet/defaults.rb +++ b/lib/puppet/defaults.rb @@ -453,6 +453,12 @@ module Puppet :reporturl => ["http://localhost:3000/reports", "The URL used by the http reports processor to send reports"], :fileserverconfig => ["$confdir/fileserver.conf", "Where the fileserver configuration is stored."], + :strict_hostname_checking => [false, "Whether to only search for the complete + hostname as it is in the certificate when searching for node information + in the catalogs."] + ) + + setdefaults(:metrics, :rrddir => {:default => "$vardir/rrd", :owner => "service", :group => "service", @@ -461,10 +467,7 @@ module Puppet this directory." }, :rrdinterval => ["$runinterval", "How often RRD should expect data. - This should match how often the hosts report back to the server."], - :strict_hostname_checking => [false, "Whether to only search for the complete - hostname as it is in the certificate when searching for node information - in the catalogs."] + This should match how often the hosts report back to the server."] ) setdefaults(:agent, -- cgit From efeb2f4d8d62073e037798b78280dadd2fc7713d Mon Sep 17 00:00:00 2001 From: Nigel Kersten Date: Mon, 11 Oct 2010 14:28:53 -0700 Subject: Make --mkusers work on OS X, we now find unused uid/gids if unspecified like other platforms. --- .../provider/nameservice/directoryservice.rb | 34 +++++++++++++++++++++- 1 file changed, 33 insertions(+), 1 deletion(-) (limited to 'lib') diff --git a/lib/puppet/provider/nameservice/directoryservice.rb b/lib/puppet/provider/nameservice/directoryservice.rb index 965a2aa60..106d99eb3 100644 --- a/lib/puppet/provider/nameservice/directoryservice.rb +++ b/lib/puppet/provider/nameservice/directoryservice.rb @@ -321,6 +321,31 @@ class DirectoryService < Puppet::Provider::NameService password_hash end + # Unlike most other *nixes, OS X doesn't provide built in functionality + # for automatically assigning uids and gids to accounts, so we set up these + # methods for consumption by functionality like --mkusers + # By default we restrict to a reasonably sane range for system accounts + def self.next_system_id(id_type, min_id=20) + dscl_args = ['.', '-list'] + if id_type == 'uid' + dscl_args << '/Users' << 'uid' + elsif id_type == 'gid' + dscl_args << '/Groups' << 'gid' + else + fail("Invalid id_type #{id_type}. Only 'uid' and 'gid' supported") + end + dscl_out = dscl(dscl_args) + # We're ok with throwing away negative uids here. + ids = dscl_out.split.compact.collect { |l| l.to_i if l.match(/^\d+$/) } + ids.compact!.sort! { |a,b| a.to_f <=> b.to_f } + # We're just looking for an unused id in our sorted array. + ids.each_index do |i| + next_id = ids[i] + 1 + return next_id if ids[i+1] != next_id and next_id >= min_id + end + end + + def ensure=(ensure_value) super # We need to loop over all valid properties for the type we're @@ -422,7 +447,14 @@ class DirectoryService < Puppet::Provider::NameService # Now we create all the standard properties Puppet::Type.type(@resource.class.name).validproperties.each do |property| next if property == :ensure - if value = @resource.should(property) and value != "" + value = @resource.should(property) + if property == :gid and value.nil? + value = self.class.next_system_id(id_type='gid') + end + if property == :uid and value.nil? + value = self.class.next_system_id(id_type='uid') + end + if value != "" and not value.nil? if property == :members add_members(nil, value) else -- cgit