blob: 1e7bdb81cbadbd1fc9205a4147ea9619e60a6946 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
|
require 'puppet/parser/ast/branch'
class Puppet::Parser::AST
# The basic container class. This object behaves almost identically
# to a normal array except at initialization time. Note that its name
# is 'AST::ASTArray', rather than plain 'AST::Array'; I had too many
# bugs when it was just 'AST::Array', because things like
# 'object.is_a?(Array)' never behaved as I expected.
class ASTArray < Branch
include Enumerable
# Return a child by index. Probably never used.
def [](index)
@children[index]
end
# Evaluate our children.
def evaluate(scope)
rets = nil
# We basically always operate declaratively, and when we
# do we need to evaluate the settor-like statements first. This
# is basically variable and type-default declarations.
if scope.declarative?
test = [
AST::VarDef, AST::TypeDefaults
]
settors = []
others = []
@children.each { |child|
if test.include?(child.class)
settors.push child
else
others.push child
end
}
rets = [settors,others].flatten.collect { |child|
child.safeevaluate(scope)
}
else
# If we're not declarative, just do everything in order.
rets = @children.collect { |item|
item.safeevaluate(scope)
}
end
rets = rets.reject { |obj| obj.nil? }
return rets
end
def push(*ary)
ary.each { |child|
#Puppet.debug "adding %s(%s) of type %s to %s" %
# [child, child.object_id, child.class.to_s.sub(/.+::/,''),
# self.object_id]
@children.push(child)
}
return self
end
# Convert to a string. Only used for printing the parse tree.
def to_s
return "[" + @children.collect { |child|
child.to_s
}.join(", ") + "]"
end
# Print the parse tree.
def tree(indent = 0)
#puts((AST.indent * indent) + self.pin)
self.collect { |child|
child.tree(indent)
}.join("\n" + (AST.midline * (indent+1)) + "\n")
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 ObjectInst < ASTArray; end
# Another simple container class to make sure we can correctly arrayfy
# things.
class CompArgument < ASTArray; end
end
|
