rubyang 0.1.2.1 → 0.1.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (38) hide show
  1. checksums.yaml +5 -5
  2. data/.gitignore +3 -0
  3. data/.rspec +1 -0
  4. data/.travis.yml +6 -3
  5. data/lib/rubyang.rb +5 -6
  6. data/lib/rubyang/cli.rb +114 -114
  7. data/lib/rubyang/cli/parser.rb +56 -56
  8. data/lib/rubyang/compat.rb +14 -0
  9. data/lib/rubyang/component/base.rb +21 -21
  10. data/lib/rubyang/component/example.rb +8 -7
  11. data/lib/rubyang/database.rb +45 -34
  12. data/lib/rubyang/database/component_manager.rb +64 -64
  13. data/lib/rubyang/database/data_tree.rb +1110 -1077
  14. data/lib/rubyang/database/helper.rb +31 -30
  15. data/lib/rubyang/database/logger.rb +58 -0
  16. data/lib/rubyang/database/schema_tree.rb +1198 -1298
  17. data/lib/rubyang/model.rb +1139 -923
  18. data/lib/rubyang/model/logger.rb +58 -0
  19. data/lib/rubyang/model/parser.rb +197 -195
  20. data/lib/rubyang/model/parser/parser.tab.rb +1373 -1263
  21. data/lib/rubyang/model/parser/parser.y +393 -215
  22. data/lib/rubyang/restapi.rb +4 -3
  23. data/lib/rubyang/restapi/app.rb +52 -53
  24. data/lib/rubyang/server.rb +4 -3
  25. data/lib/rubyang/server/base.rb +20 -20
  26. data/lib/rubyang/server/example.rb +2 -1
  27. data/lib/rubyang/version.rb +4 -1
  28. data/lib/rubyang/webui.rb +4 -3
  29. data/lib/rubyang/webui/app.rb +62 -63
  30. data/lib/rubyang/webui/make_json_schema.rb +49 -48
  31. data/lib/rubyang/xpath.rb +458 -456
  32. data/lib/rubyang/xpath/logger.rb +58 -0
  33. data/lib/rubyang/xpath/parser.rb +134 -144
  34. data/lib/rubyang/xpath/parser/parser.tab.rb +373 -616
  35. data/lib/rubyang/xpath/parser/parser.y +249 -492
  36. data/rubyang.gemspec +11 -15
  37. metadata +49 -32
  38. data/lib/rubyang/logger.rb +0 -19
data/lib/rubyang/xpath/logger.rb ADDED
@@ -0,0 +1,58 @@
1
+ # coding: utf-8
2
+ # vim: et ts=2 sw=2
3
+
4
+ module Rubyang
5
+ module Xpath
6
+ class Logger
7
+ @@logger = nil
8
+
9
+ class << self
10
+ def initialize logger
11
+ @@logger = logger
12
+ end
13
+
14
+ def uninitialize
15
+ @@logger = nil
16
+ end
17
+
18
+ def initialized?
19
+ @@logger != nil
20
+ end
21
+ end
22
+
23
+ def initialize name
24
+ @name = name
25
+ end
26
+
27
+ def fatal
28
+ if @@logger
29
+ @@logger.fatal { "#{@name}: #{yield}" }
30
+ end
31
+ end
32
+
33
+ def error
34
+ if @@logger
35
+ @@logger.error { "#{@name}: #{yield}" }
36
+ end
37
+ end
38
+
39
+ def warn
40
+ if @@logger
41
+ @@logger.warn { "#{@name}: #{yield}" }
42
+ end
43
+ end
44
+
45
+ def info
46
+ if @@logger
47
+ @@logger.info { "#{@name}: #{yield}" }
48
+ end
49
+ end
50
+
51
+ def debug
52
+ if @@logger
53
+ @@logger.debug { "#{@name}: #{yield}" }
54
+ end
55
+ end
56
+ end
57
+ end
58
+ end
data/lib/rubyang/xpath/parser.rb CHANGED
@@ -1,156 +1,146 @@
1
1
  # coding: utf-8
2
+ # vim: et ts=2 sw=2
2
3
 
3
4
  require 'strscan'
4
-
5
- require_relative '../xpath.rb'
6
-
7
- require_relative 'parser/parser.tab.rb'
5
+ require 'rubyang/xpath'
6
+ require 'rubyang/xpath/parser/parser.tab.rb'
8
7
 
9
8
  module Rubyang
10
- module Xpath
11
- class Parser
12
- DEBUG ||= false
13
-
14
- def self.parse( xpath_str )
15
- parser = self.new
16
- parser.parse( xpath_str )
17
- end
18
-
19
- def initialize
20
- end
21
-
22
- def parse( xpath_str )
23
- @tokens = Array.new
24
-
25
- s = StringScanner.new( xpath_str )
26
-
27
- scanre_list = [
28
- ["(", /^\(/],
29
- [")", /^\)/],
30
- ["[", /^\[/],
31
- ["]", /^\]/],
32
- ["..", /^\.\./],
33
- [".", /^\./],
34
- ["@", /^\@/],
35
- [",", /^\,/],
36
- ["::", /^\:\:/],
37
- ["Literal", /^(?:"[^"]*"|'[^']*')/],
38
- ["Digits", /^[0-9]+/],
39
- ["//", /^\/\//],
40
- ["/", /^\//],
41
- ["|", /^\|/],
42
- ["+", /^\+/],
43
- ["-", /^\-/],
44
- ["!=", /^\!\=/],
45
- ["<=", /^\<\=/],
46
- [">=", /^\>\=/],
47
- ["=", /^\=/],
48
- ["<", /^\</],
49
- [">", /^\>/],
50
- ["and", /^and/],
51
- ["or", /^or/],
52
- ["mod", /^mod/],
53
- ["div", /^div/],
54
- ["$", /^\$/],
55
- ["*", /^\*/],
56
- [":", /^\:/],
57
- ["S", /^[ \t]+/],
58
- # NodeType
59
- ["comment", /^comment/],
60
- ["text", /^text/],
61
- ["node", /^node/],
62
- # ProcessingInstruction
63
- ["processing-instruction", /^processing-instruction/],
64
- # Axis
65
- ["ancestor", /^ancestor/],
66
- ["ancestor-or-self", /^ancestor-or-self/],
67
- ["attribute", /^attribute/],
68
- ["child", /^child/],
69
- ["descendant", /^descendant/],
70
- ["descendant-or-self", /^descendant-or-self/],
71
- ["following", /^following/],
72
- ["following-sibling", /^following-sibling/],
73
- ["namespace", /^namespace/],
74
- ["parent", /^parent/],
75
- ["preceding", /^preceding/],
76
- ["preceding-sibling", /^preceding-sibling/],
77
- ["self", /^self/],
78
- # FunctionName
79
- ["last(", /^last[ \t]*\(/],
80
- ["position(", /^position[ \t]*\(/],
81
- ["count(", /^count[ \t]*\(/],
82
- ["id(", /^id[ \t]*\(/],
83
- ["local-name(", /^local-name[ \t]*\(/],
84
- ["namespace-uri(", /^namespace-uri[ \t]*\(/],
85
- ["name(", /^name[ \t]*\(/],
86
- ["string(", /^string[ \t]*\(/],
87
- ["concat(", /^concat[ \t]*\(/],
88
- ["starts-with(", /^starts-with[ \t]*\(/],
89
- ["contains(", /^contains[ \t]*\(/],
90
- ["substring-before(", /^substring-before[ \t]*\(/],
91
- ["substring-after(", /^substring-after[ \t]*\(/],
92
- ["substring(", /^substring[ \t]*\(/],
93
- ["string-length(", /^string-length[ \t]*\(/],
94
- ["normalize-space(", /^normalize-space[ \t]*\(/],
95
- ["translate(", /^translate[ \t]*\(/],
96
- ["boolean(", /^boolean[ \t]*\(/],
97
- ["not(", /^not[ \t]*\(/],
98
- ["true(", /^true[ \t]*\(/],
99
- ["false(", /^false[ \t]*\(/],
100
- ["lang(", /^lang[ \t]*\(/],
101
- ["number(", /^number[ \t]*\(/],
102
- ["sum(", /^sum[ \t]*\(/],
103
- ["floor(", /^floor[ \t]*\(/],
104
- ["ceiling(", /^ceiling[ \t]*\(/],
105
- ["round(", /^round[ \t]*\(/],
106
- ["current(", /^current[ \t]*\(/],
107
- # NCName
108
- ["NCName", /^(?:[A-Z]|\_|[a-z])(?:[A-Z]|\_|[a-z]|\-|\.|[0-9])*/],
109
- ]
110
-
111
- scanre = Regexp.union( scanre_list.map{ |scanre| scanre[1] } )
112
-
113
- until s.eos?
114
- token = s.scan( scanre )
115
- if DEBUG
116
- p token
117
- end
118
- next if "S" == scanre_list.find{ |s| s[1] =~ token }[0]
119
- @tokens.push [scanre_list.find{ |s| s[1] =~ token }[0], token]
120
- if DEBUG
121
- p @tokens.last
122
- end
123
- end
124
-
125
- if DEBUG
126
- p 'run do_parse'
127
- end
128
- result = self.do_parse
129
- result
130
- end
131
-
132
- def next_token
133
- if DEBUG
134
- p @tokens.first
135
- end
136
- @tokens.shift
137
- end
138
- end
139
- end
9
+ module Xpath
10
+ class Parser
11
+ def self.parse( xpath_str )
12
+ parser = self.new
13
+ parser.parse( xpath_str )
14
+ end
15
+
16
+ def initialize
17
+ @logger = Logger.new(self.class.name)
18
+ end
19
+
20
+ def parse( xpath_str )
21
+ @tokens = Array.new
22
+
23
+ s = StringScanner.new( xpath_str )
24
+
25
+ scanre_list = [
26
+ ["(", /^\(/],
27
+ [")", /^\)/],
28
+ ["[", /^\[/],
29
+ ["]", /^\]/],
30
+ ["..", /^\.\./],
31
+ [".", /^\./],
32
+ ["@", /^\@/],
33
+ [",", /^\,/],
34
+ ["::", /^\:\:/],
35
+ ["Literal", /^(?:"[^"]*"|'[^']*')/],
36
+ ["Digits", /^[0-9]+/],
37
+ ["//", /^\/\//],
38
+ ["/", /^\//],
39
+ ["|", /^\|/],
40
+ ["+", /^\+/],
41
+ ["-", /^\-/],
42
+ ["!=", /^\!\=/],
43
+ ["<=", /^\<\=/],
44
+ [">=", /^\>\=/],
45
+ ["=", /^\=/],
46
+ ["<", /^\</],
47
+ [">", /^\>/],
48
+ ["and", /^and/],
49
+ ["or", /^or/],
50
+ ["mod", /^mod/],
51
+ ["div", /^div/],
52
+ ["$", /^\$/],
53
+ ["*", /^\*/],
54
+ [":", /^\:/],
55
+ ["S", /^[ \t]+/],
56
+ # NodeType
57
+ ["comment", /^comment/],
58
+ ["text", /^text/],
59
+ ["node", /^node/],
60
+ # ProcessingInstruction
61
+ ["processing-instruction", /^processing-instruction/],
62
+ # Axis
63
+ ["ancestor", /^ancestor/],
64
+ ["ancestor-or-self", /^ancestor-or-self/],
65
+ ["attribute", /^attribute/],
66
+ ["child", /^child/],
67
+ ["descendant", /^descendant/],
68
+ ["descendant-or-self", /^descendant-or-self/],
69
+ ["following", /^following/],
70
+ ["following-sibling", /^following-sibling/],
71
+ ["namespace", /^namespace/],
72
+ ["parent", /^parent/],
73
+ ["preceding", /^preceding/],
74
+ ["preceding-sibling", /^preceding-sibling/],
75
+ ["self", /^self/],
76
+ # FunctionName
77
+ ["last(", /^last[ \t]*\(/],
78
+ ["position(", /^position[ \t]*\(/],
79
+ ["count(", /^count[ \t]*\(/],
80
+ ["id(", /^id[ \t]*\(/],
81
+ ["local-name(", /^local-name[ \t]*\(/],
82
+ ["namespace-uri(", /^namespace-uri[ \t]*\(/],
83
+ ["name(", /^name[ \t]*\(/],
84
+ ["string(", /^string[ \t]*\(/],
85
+ ["concat(", /^concat[ \t]*\(/],
86
+ ["starts-with(", /^starts-with[ \t]*\(/],
87
+ ["contains(", /^contains[ \t]*\(/],
88
+ ["substring-before(", /^substring-before[ \t]*\(/],
89
+ ["substring-after(", /^substring-after[ \t]*\(/],
90
+ ["substring(", /^substring[ \t]*\(/],
91
+ ["string-length(", /^string-length[ \t]*\(/],
92
+ ["normalize-space(", /^normalize-space[ \t]*\(/],
93
+ ["translate(", /^translate[ \t]*\(/],
94
+ ["boolean(", /^boolean[ \t]*\(/],
95
+ ["not(", /^not[ \t]*\(/],
96
+ ["true(", /^true[ \t]*\(/],
97
+ ["false(", /^false[ \t]*\(/],
98
+ ["lang(", /^lang[ \t]*\(/],
99
+ ["number(", /^number[ \t]*\(/],
100
+ ["sum(", /^sum[ \t]*\(/],
101
+ ["floor(", /^floor[ \t]*\(/],
102
+ ["ceiling(", /^ceiling[ \t]*\(/],
103
+ ["round(", /^round[ \t]*\(/],
104
+ ["current(", /^current[ \t]*\(/],
105
+ # NCName
106
+ ["NCName", /^(?:[A-Z]|\_|[a-z])(?:[A-Z]|\_|[a-z]|\-|\.|[0-9])*/],
107
+ ]
108
+
109
+ scanre = Regexp.union( scanre_list.map{ |scanre| scanre[1] } )
110
+
111
+ until s.eos?
112
+ token = s.scan( scanre )
113
+ @logger.debug { token }
114
+ next if "S" == scanre_list.find{ |s| s[1] =~ token }[0]
115
+ @tokens.push [scanre_list.find{ |s| s[1] =~ token }[0], token]
116
+ @logger.debug { @tokens.last }
117
+ end
118
+
119
+ @logger.debug { 'run do_parse' }
120
+ result = self.do_parse
121
+ result
122
+ end
123
+
124
+ def next_token
125
+ @logger.debug { @tokens.first }
126
+ @tokens.shift
127
+ end
128
+ end
129
+ end
140
130
  end
141
131
 
142
132
  if __FILE__ == $0
143
- require 'yaml'
133
+ require 'yaml'
144
134
 
145
- #str = "../leaf0"
146
- #xpath = Rubyang::Xpath::Parser.parse(str)
147
- #puts xpath.to_yaml
135
+ #str = "../leaf0"
136
+ #xpath = Rubyang::Xpath::Parser.parse(str)
137
+ #puts xpath.to_yaml
148
138
 
149
- #str = "/hoge"
150
- #xpath = Rubyang::Xpath::Parser.parse(str)
151
- #puts xpath.to_yaml
139
+ #str = "/hoge"
140
+ #xpath = Rubyang::Xpath::Parser.parse(str)
141
+ #puts xpath.to_yaml
152
142
 
153
- str = "../hoge[name1 = current()/../container1/name]/leaf"
154
- xpath = Rubyang::Xpath::Parser.parse(str)
155
- puts xpath.to_yaml
143
+ str = "../hoge[name1 = current()/../container1/name]/leaf"
144
+ xpath = Rubyang::Xpath::Parser.parse(str)
145
+ puts xpath.to_yaml
156
146
  end
data/lib/rubyang/xpath/parser/parser.tab.rb CHANGED
@@ -8,6 +8,10 @@ require 'racc/parser.rb'
8
8
  module Rubyang
9
9
  module Xpath
10
10
  class Parser < Racc::Parser
11
+
12
+ module_eval(<<'...end parser.y/module_eval...', 'parser.y', 836)
13
+ @@logger = Logger.new(self.name)
14
+ ...end parser.y/module_eval...
11
15
  ##### State transition tables begin ###
12
16
 
13
17
  racc_action_table = [
@@ -746,46 +750,38 @@ Racc_debug_parser = false
746
750
 
747
751
  module_eval(<<'.,.,', 'parser.y', 5)
748
752
  def _reduce_1(val, _values, result)
749
- if Rubyang::Xpath::Parser::DEBUG
750
- puts 'statement : Expr'
751
- puts "val: #{val.inspect}"
752
- end
753
+ @@logger.debug { 'statement : Expr' }
754
+ @@logger.debug { "val: #{val.inspect}" }
753
755
  result = Rubyang::Xpath::Expr.new val[0]
754
756
 
755
757
  result
756
758
  end
757
759
  .,.,
758
760
 
759
- module_eval(<<'.,.,', 'parser.y', 14)
761
+ module_eval(<<'.,.,', 'parser.y', 12)
760
762
  def _reduce_2(val, _values, result)
761
- if Rubyang::Xpath::Parser::DEBUG
762
- puts '"LocationPath" : "RelativeLocationPath"'
763
- puts "val: #{val.inspect}"
764
- end
763
+ @@logger.debug { '"LocationPath" : "RelativeLocationPath"' }
764
+ @@logger.debug { "val: #{val.inspect}" }
765
765
  result = val[0]
766
766
 
767
767
  result
768
768
  end
769
769
  .,.,
770
770
 
771
- module_eval(<<'.,.,', 'parser.y', 22)
771
+ module_eval(<<'.,.,', 'parser.y', 18)
772
772
  def _reduce_3(val, _values, result)
773
- if Rubyang::Xpath::Parser::DEBUG
774
- puts '"LocationPath" : "AbsoluteLocationPath"'
775
- puts "val: #{val.inspect}"
776
- end
773
+ @@logger.debug { '"LocationPath" : "AbsoluteLocationPath"' }
774
+ @@logger.debug { "val: #{val.inspect}" }
777
775
  result = val[0]
778
776
 
779
777
  result
780
778
  end
781
779
  .,.,
782
780
 
783
- module_eval(<<'.,.,', 'parser.y', 31)
781
+ module_eval(<<'.,.,', 'parser.y', 25)
784
782
  def _reduce_4(val, _values, result)
785
- if Rubyang::Xpath::Parser::DEBUG
786
- puts '"AbsoluteLocationPath" : "/"'
787
- puts "val: #{val.inspect}"
788
- end
783
+ @@logger.debug { '"AbsoluteLocationPath" : "/"' }
784
+ @@logger.debug { "val: #{val.inspect}" }
789
785
  axis = Rubyang::Xpath::Axis.new Rubyang::Xpath::Axis::SELF
790
786
  node_test = Rubyang::Xpath::NodeTest.new Rubyang::Xpath::NodeTest::NodeTestType::NAME_TEST, '/'
791
787
  predicates = Rubyang::Xpath::Predicates.new
@@ -796,12 +792,10 @@ module_eval(<<'.,.,', 'parser.y', 31)
796
792
  end
797
793
  .,.,
798
794
 
799
- module_eval(<<'.,.,', 'parser.y', 43)
795
+ module_eval(<<'.,.,', 'parser.y', 35)
800
796
  def _reduce_5(val, _values, result)
801
- if Rubyang::Xpath::Parser::DEBUG
802
- puts '"AbsoluteLocationPath" : "/" "RelativeLocationPath"'
803
- puts "val: #{val.inspect}"
804
- end
797
+ @@logger.debug { '"AbsoluteLocationPath" : "/" "RelativeLocationPath"' }
798
+ @@logger.debug { "val: #{val.inspect}" }
805
799
  axis = Rubyang::Xpath::Axis.new Rubyang::Xpath::Axis::SELF
806
800
  node_test = Rubyang::Xpath::NodeTest.new Rubyang::Xpath::NodeTest::NodeTestType::NAME_TEST, '/'
807
801
  predicates = Rubyang::Xpath::Predicates.new
@@ -812,103 +806,87 @@ module_eval(<<'.,.,', 'parser.y', 43)
812
806
  end
813
807
  .,.,
814
808
 
815
- module_eval(<<'.,.,', 'parser.y', 55)
809
+ module_eval(<<'.,.,', 'parser.y', 45)
816
810
  def _reduce_6(val, _values, result)
817
- if Rubyang::Xpath::Parser::DEBUG
818
- puts '"AbsoluteLocationPath" : "AbbreviatedAbsoluteLocationPath"'
819
- puts "val: #{val.inspect}"
820
- end
811
+ @@logger.debug { '"AbsoluteLocationPath" : "AbbreviatedAbsoluteLocationPath"' }
812
+ @@logger.debug { "val: #{val.inspect}" }
821
813
  result = val[0]
822
814
 
823
815
  result
824
816
  end
825
817
  .,.,
826
818
 
827
- module_eval(<<'.,.,', 'parser.y', 64)
819
+ module_eval(<<'.,.,', 'parser.y', 52)
828
820
  def _reduce_7(val, _values, result)
829
- if Rubyang::Xpath::Parser::DEBUG
830
- puts '"RelativeLocationPath" : "Step"'
831
- puts "val: #{val.inspect}"
832
- end
821
+ @@logger.debug { '"RelativeLocationPath" : "Step"' }
822
+ @@logger.debug { "val: #{val.inspect}" }
833
823
  result = Rubyang::Xpath::LocationPath.new val[0]
834
824
 
835
825
  result
836
826
  end
837
827
  .,.,
838
828
 
839
- module_eval(<<'.,.,', 'parser.y', 72)
829
+ module_eval(<<'.,.,', 'parser.y', 58)
840
830
  def _reduce_8(val, _values, result)
841
- if Rubyang::Xpath::Parser::DEBUG
842
- puts '"RelativeLocationPath" : "RelativeLocationPath" "/" "Step"'
843
- puts "val: #{val.inspect}"
844
- end
831
+ @@logger.debug { '"RelativeLocationPath" : "RelativeLocationPath" "/" "Step"' }
832
+ @@logger.debug { "val: #{val.inspect}" }
845
833
  result = val[0].add val[2]
846
834
 
847
835
  result
848
836
  end
849
837
  .,.,
850
838
 
851
- module_eval(<<'.,.,', 'parser.y', 80)
839
+ module_eval(<<'.,.,', 'parser.y', 64)
852
840
  def _reduce_9(val, _values, result)
853
- if Rubyang::Xpath::Parser::DEBUG
854
- puts '"RelativeLocationPath" : "AbbreviatedRelativeLocationPath"'
855
- puts "val: #{val.inspect}"
856
- end
841
+ @@logger.debug { '"RelativeLocationPath" : "AbbreviatedRelativeLocationPath"' }
842
+ @@logger.debug { "val: #{val.inspect}" }
857
843
  result = val[0]
858
844
 
859
845
  result
860
846
  end
861
847
  .,.,
862
848
 
863
- module_eval(<<'.,.,', 'parser.y', 89)
849
+ module_eval(<<'.,.,', 'parser.y', 71)
864
850
  def _reduce_10(val, _values, result)
865
- if Rubyang::Xpath::Parser::DEBUG
866
- puts '"Step" : "AxisSpecifier" "NodeTest" "Predicates"'
867
- puts "val: #{val.inspect}"
868
- end
851
+ @@logger.debug { '"Step" : "AxisSpecifier" "NodeTest" "Predicates"' }
852
+ @@logger.debug { "val: #{val.inspect}" }
869
853
  result = Rubyang::Xpath::LocationStep.new val[0], val[1], val[2]
870
854
 
871
855
  result
872
856
  end
873
857
  .,.,
874
858
 
875
- module_eval(<<'.,.,', 'parser.y', 97)
859
+ module_eval(<<'.,.,', 'parser.y', 77)
876
860
  def _reduce_11(val, _values, result)
877
- if Rubyang::Xpath::Parser::DEBUG
878
- puts '"Step" : "AbbreviatedStep"'
879
- puts "val: #{val.inspect}"
880
- end
861
+ @@logger.debug { '"Step" : "AbbreviatedStep"' }
862
+ @@logger.debug { "val: #{val.inspect}" }
881
863
  result = val[0]
882
864
 
883
865
  result
884
866
  end
885
867
  .,.,
886
868
 
887
- module_eval(<<'.,.,', 'parser.y', 106)
869
+ module_eval(<<'.,.,', 'parser.y', 84)
888
870
  def _reduce_12(val, _values, result)
889
- if Rubyang::Xpath::Parser::DEBUG
890
- puts '"AxisSpecifier" : "AxisName" "::"'
891
- puts "val: #{val.inspect}"
892
- end
871
+ @@logger.debug { '"AxisSpecifier" : "AxisName" "::"' }
872
+ @@logger.debug { "val: #{val.inspect}" }
893
873
  result = Rubyang::Xpath::Axis.new val[0]
894
874
 
895
875
  result
896
876
  end
897
877
  .,.,
898
878
 
899
- module_eval(<<'.,.,', 'parser.y', 114)
879
+ module_eval(<<'.,.,', 'parser.y', 90)
900
880
  def _reduce_13(val, _values, result)
901
- if Rubyang::Xpath::Parser::DEBUG
902
- puts '"AxisSpecifier" : "AbbreviatedAxisSpecifier"'
903
- puts "val: #{val.inspect}"
904
- end
881
+ @@logger.debug { '"AxisSpecifier" : "AbbreviatedAxisSpecifier"' }
882
+ @@logger.debug { "val: #{val.inspect}" }
905
883
  result = Rubyang::Xpath::Axis.new val[0]
906
884
 
907
885
  result
908
886
  end
909
887
  .,.,
910
888
 
911
- module_eval(<<'.,.,', 'parser.y', 123)
889
+ module_eval(<<'.,.,', 'parser.y', 97)
912
890
  def _reduce_14(val, _values, result)
913
891
  result = Rubyang::Xpath::Predicates.new
914
892
 
@@ -916,180 +894,150 @@ module_eval(<<'.,.,', 'parser.y', 123)
916
894
  end
917
895
  .,.,
918
896
 
919
- module_eval(<<'.,.,', 'parser.y', 127)
897
+ module_eval(<<'.,.,', 'parser.y', 101)
920
898
  def _reduce_15(val, _values, result)
921
- if Rubyang::Xpath::Parser::DEBUG
922
- puts '"Predicates" : "Predicates" "Predicate"'
923
- puts "val: #{val.inspect}"
924
- end
899
+ @@logger.debug { '"Predicates" : "Predicates" "Predicate"' }
900
+ @@logger.debug { "val: #{val.inspect}" }
925
901
  result = val[0].push val[1]
926
902
 
927
903
  result
928
904
  end
929
905
  .,.,
930
906
 
931
- module_eval(<<'.,.,', 'parser.y', 136)
907
+ module_eval(<<'.,.,', 'parser.y', 108)
932
908
  def _reduce_16(val, _values, result)
933
- if Rubyang::Xpath::Parser::DEBUG
934
- puts '"AxisName" : "ancestor"'
935
- puts "val: #{val.inspect}"
936
- end
909
+ @@logger.debug { '"AxisName" : "ancestor"' }
910
+ @@logger.debug { "val: #{val.inspect}" }
937
911
  result = Rubyang::Xpath::Axis::ANCESTOR
938
912
 
939
913
  result
940
914
  end
941
915
  .,.,
942
916
 
943
- module_eval(<<'.,.,', 'parser.y', 144)
917
+ module_eval(<<'.,.,', 'parser.y', 114)
944
918
  def _reduce_17(val, _values, result)
945
- if Rubyang::Xpath::Parser::DEBUG
946
- puts '"AxisName" : "ancestor-or-self"'
947
- puts "val: #{val.inspect}"
948
- end
919
+ @@logger.debug { '"AxisName" : "ancestor-or-self"' }
920
+ @@logger.debug { "val: #{val.inspect}" }
949
921
  result = Rubyang::Xpath::Axis::ANCESTOR_OR_SELF
950
922
 
951
923
  result
952
924
  end
953
925
  .,.,
954
926
 
955
- module_eval(<<'.,.,', 'parser.y', 152)
927
+ module_eval(<<'.,.,', 'parser.y', 120)
956
928
  def _reduce_18(val, _values, result)
957
- if Rubyang::Xpath::Parser::DEBUG
958
- puts '"AxisName" : "attribute"'
959
- puts "val: #{val.inspect}"
960
- end
929
+ @@logger.debug { '"AxisName" : "attribute"' }
930
+ @@logger.debug { "val: #{val.inspect}" }
961
931
  result = Rubyang::Xpath::Axis::ATTRIBUTE
962
932
 
963
933
  result
964
934
  end
965
935
  .,.,
966
936
 
967
- module_eval(<<'.,.,', 'parser.y', 160)
937
+ module_eval(<<'.,.,', 'parser.y', 126)
968
938
  def _reduce_19(val, _values, result)
969
- if Rubyang::Xpath::Parser::DEBUG
970
- puts '"AxisName" : "child"'
971
- puts "val: #{val.inspect}"
972
- end
939
+ @@logger.debug { '"AxisName" : "child"' }
940
+ @@logger.debug { "val: #{val.inspect}" }
973
941
  result = Rubyang::Xpath::Axis::CHILD
974
942
 
975
943
  result
976
944
  end
977
945
  .,.,
978
946
 
979
- module_eval(<<'.,.,', 'parser.y', 168)
947
+ module_eval(<<'.,.,', 'parser.y', 132)
980
948
  def _reduce_20(val, _values, result)
981
- if Rubyang::Xpath::Parser::DEBUG
982
- puts '"AxisName" : "descendant"'
983
- puts "val: #{val.inspect}"
984
- end
949
+ @@logger.debug { '"AxisName" : "descendant"' }
950
+ @@logger.debug { "val: #{val.inspect}" }
985
951
  result = Rubyang::Xpath::Axis::DESCENDANT
986
952
 
987
953
  result
988
954
  end
989
955
  .,.,
990
956
 
991
- module_eval(<<'.,.,', 'parser.y', 176)
957
+ module_eval(<<'.,.,', 'parser.y', 138)
992
958
  def _reduce_21(val, _values, result)
993
- if Rubyang::Xpath::Parser::DEBUG
994
- puts '"AxisName" : "descendant-or-self"'
995
- puts "val: #{val.inspect}"
996
- end
959
+ @@logger.debug { '"AxisName" : "descendant-or-self"' }
960
+ @@logger.debug { "val: #{val.inspect}" }
997
961
  result = Rubyang::Xpath::Axis::DESCENDANT_OR_SELF
998
962
 
999
963
  result
1000
964
  end
1001
965
  .,.,
1002
966
 
1003
- module_eval(<<'.,.,', 'parser.y', 184)
967
+ module_eval(<<'.,.,', 'parser.y', 144)
1004
968
  def _reduce_22(val, _values, result)
1005
- if Rubyang::Xpath::Parser::DEBUG
1006
- puts '"AxisName" : "following"'
1007
- puts "val: #{val.inspect}"
1008
- end
969
+ @@logger.debug { '"AxisName" : "following"' }
970
+ @@logger.debug { "val: #{val.inspect}" }
1009
971
  result = Rubyang::Xpath::Axis::FOLLOWING
1010
972
 
1011
973
  result
1012
974
  end
1013
975
  .,.,
1014
976
 
1015
- module_eval(<<'.,.,', 'parser.y', 192)
977
+ module_eval(<<'.,.,', 'parser.y', 150)
1016
978
  def _reduce_23(val, _values, result)
1017
- if Rubyang::Xpath::Parser::DEBUG
1018
- puts '"AxisName" : "following-sibling"'
1019
- puts "val: #{val.inspect}"
1020
- end
979
+ @@logger.debug { '"AxisName" : "following-sibling"' }
980
+ @@logger.debug { "val: #{val.inspect}" }
1021
981
  result = Rubyang::Xpath::Axis::FOLLOWING_SIBLING
1022
982
 
1023
983
  result
1024
984
  end
1025
985
  .,.,
1026
986
 
1027
- module_eval(<<'.,.,', 'parser.y', 200)
987
+ module_eval(<<'.,.,', 'parser.y', 156)
1028
988
  def _reduce_24(val, _values, result)
1029
- if Rubyang::Xpath::Parser::DEBUG
1030
- puts '"AxisName" : "namespace"'
1031
- puts "val: #{val.inspect}"
1032
- end
989
+ @@logger.debug { '"AxisName" : "namespace"' }
990
+ @@logger.debug { "val: #{val.inspect}" }
1033
991
  result = Rubyang::Xpath::Axis::NAMESPACE
1034
992
 
1035
993
  result
1036
994
  end
1037
995
  .,.,
1038
996
 
1039
- module_eval(<<'.,.,', 'parser.y', 208)
997
+ module_eval(<<'.,.,', 'parser.y', 162)
1040
998
  def _reduce_25(val, _values, result)
1041
- if Rubyang::Xpath::Parser::DEBUG
1042
- puts '"AxisName" : "parent"'
1043
- puts "val: #{val.inspect}"
1044
- end
999
+ @@logger.debug { '"AxisName" : "parent"' }
1000
+ @@logger.debug { "val: #{val.inspect}" }
1045
1001
  result = Rubyang::Xpath::Axis::PARENT
1046
1002
 
1047
1003
  result
1048
1004
  end
1049
1005
  .,.,
1050
1006
 
1051
- module_eval(<<'.,.,', 'parser.y', 216)
1007
+ module_eval(<<'.,.,', 'parser.y', 168)
1052
1008
  def _reduce_26(val, _values, result)
1053
- if Rubyang::Xpath::Parser::DEBUG
1054
- puts '"AxisName" : "preceding"'
1055
- puts "val: #{val.inspect}"
1056
- end
1009
+ @@logger.debug { '"AxisName" : "preceding"' }
1010
+ @@logger.debug { "val: #{val.inspect}" }
1057
1011
  result = Rubyang::Xpath::Axis::PRECEDING
1058
1012
 
1059
1013
  result
1060
1014
  end
1061
1015
  .,.,
1062
1016
 
1063
- module_eval(<<'.,.,', 'parser.y', 224)
1017
+ module_eval(<<'.,.,', 'parser.y', 174)
1064
1018
  def _reduce_27(val, _values, result)
1065
- if Rubyang::Xpath::Parser::DEBUG
1066
- puts '"AxisName" : "preceding-sibling"'
1067
- puts "val: #{val.inspect}"
1068
- end
1019
+ @@logger.debug { '"AxisName" : "preceding-sibling"' }
1020
+ @@logger.debug { "val: #{val.inspect}" }
1069
1021
  result = Rubyang::Xpath::Axis::PRECEDING_SIBLING
1070
1022
 
1071
1023
  result
1072
1024
  end
1073
1025
  .,.,
1074
1026
 
1075
- module_eval(<<'.,.,', 'parser.y', 232)
1027
+ module_eval(<<'.,.,', 'parser.y', 180)
1076
1028
  def _reduce_28(val, _values, result)
1077
- if Rubyang::Xpath::Parser::DEBUG
1078
- puts '"AxisName" : "self"'
1079
- puts "val: #{val.inspect}"
1080
- end
1029
+ @@logger.debug { '"AxisName" : "self"' }
1030
+ @@logger.debug { "val: #{val.inspect}" }
1081
1031
  result = Rubyang::Xpath::Axis::SELF
1082
1032
 
1083
1033
  result
1084
1034
  end
1085
1035
  .,.,
1086
1036
 
1087
- module_eval(<<'.,.,', 'parser.y', 241)
1037
+ module_eval(<<'.,.,', 'parser.y', 187)
1088
1038
  def _reduce_29(val, _values, result)
1089
- if Rubyang::Xpath::Parser::DEBUG
1090
- puts '"NodeTest" : "NameTest"'
1091
- puts "val: #{val.inspect}"
1092
- end
1039
+ @@logger.debug { '"NodeTest" : "NameTest"' }
1040
+ @@logger.debug { "val: #{val.inspect}" }
1093
1041
  name_test_type = Rubyang::Xpath::NodeTest::NodeTestType::NAME_TEST
1094
1042
  result = Rubyang::Xpath::NodeTest.new name_test_type, val[0]
1095
1043
 
@@ -1097,12 +1045,10 @@ module_eval(<<'.,.,', 'parser.y', 241)
1097
1045
  end
1098
1046
  .,.,
1099
1047
 
1100
- module_eval(<<'.,.,', 'parser.y', 250)
1048
+ module_eval(<<'.,.,', 'parser.y', 194)
1101
1049
  def _reduce_30(val, _values, result)
1102
- if Rubyang::Xpath::Parser::DEBUG
1103
- puts '"NodeTest" : "NodeType" "(" ")"'
1104
- puts "val: #{val.inspect}"
1105
- end
1050
+ @@logger.debug { '"NodeTest" : "NodeType" "(" ")"' }
1051
+ @@logger.debug { "val: #{val.inspect}" }
1106
1052
  name_test_type = Rubyang::Xpath::NodeTest::NodeTestType::NODE_TYPE
1107
1053
  result = Rubyang::Xpath::NodeTest.new name_test_type, val[0]
1108
1054
 
@@ -1110,12 +1056,10 @@ module_eval(<<'.,.,', 'parser.y', 250)
1110
1056
  end
1111
1057
  .,.,
1112
1058
 
1113
- module_eval(<<'.,.,', 'parser.y', 259)
1059
+ module_eval(<<'.,.,', 'parser.y', 201)
1114
1060
  def _reduce_31(val, _values, result)
1115
- if Rubyang::Xpath::Parser::DEBUG
1116
- puts '"NodeTest" : "processing-instruction" "(" "Literal" ")"'
1117
- puts "val: #{val.inspect}"
1118
- end
1061
+ @@logger.debug { '"NodeTest" : "processing-instruction" "(" "Literal" ")"' }
1062
+ @@logger.debug { "val: #{val.inspect}" }
1119
1063
  name_test_type = Rubyang::Xpath::NodeTest::NodeTestType::PROCESSING_INSTRUCTION
1120
1064
  result = Rubyang::Xpath::NodeTest.new name_test_type, val[0]
1121
1065
 
@@ -1123,36 +1067,30 @@ module_eval(<<'.,.,', 'parser.y', 259)
1123
1067
  end
1124
1068
  .,.,
1125
1069
 
1126
- module_eval(<<'.,.,', 'parser.y', 269)
1070
+ module_eval(<<'.,.,', 'parser.y', 209)
1127
1071
  def _reduce_32(val, _values, result)
1128
- if Rubyang::Xpath::Parser::DEBUG
1129
- puts '"Predicate" : "[" "PredicateExpr" "]"'
1130
- puts "val: #{val.inspect}"
1131
- end
1072
+ @@logger.debug { '"Predicate" : "[" "PredicateExpr" "]"' }
1073
+ @@logger.debug { "val: #{val.inspect}" }
1132
1074
  result = Rubyang::Xpath::Predicate.new val[1]
1133
1075
 
1134
1076
  result
1135
1077
  end
1136
1078
  .,.,
1137
1079
 
1138
- module_eval(<<'.,.,', 'parser.y', 278)
1080
+ module_eval(<<'.,.,', 'parser.y', 216)
1139
1081
  def _reduce_33(val, _values, result)
1140
- if Rubyang::Xpath::Parser::DEBUG
1141
- puts '"PredicateExpr" : "Expr"'
1142
- puts "val: #{val.inspect}"
1143
- end
1082
+ @@logger.debug { '"PredicateExpr" : "Expr"' }
1083
+ @@logger.debug { "val: #{val.inspect}" }
1144
1084
  result = val[0]
1145
1085
 
1146
1086
  result
1147
1087
  end
1148
1088
  .,.,
1149
1089
 
1150
- module_eval(<<'.,.,', 'parser.y', 287)
1090
+ module_eval(<<'.,.,', 'parser.y', 223)
1151
1091
  def _reduce_34(val, _values, result)
1152
- if Rubyang::Xpath::Parser::DEBUG
1153
- puts '"AbbreviatedAbsoluteLocationPath" : "//" "RelativeLocationPath"'
1154
- puts "val: #{val.inspect}"
1155
- end
1092
+ @@logger.debug { '"AbbreviatedAbsoluteLocationPath" : "//" "RelativeLocationPath"' }
1093
+ @@logger.debug { "val: #{val.inspect}" }
1156
1094
  raise "AbbreviatedAbsoluteLocationPath is not implemented"
1157
1095
  result = val[0]
1158
1096
 
@@ -1160,12 +1098,10 @@ module_eval(<<'.,.,', 'parser.y', 287)
1160
1098
  end
1161
1099
  .,.,
1162
1100
 
1163
- module_eval(<<'.,.,', 'parser.y', 297)
1101
+ module_eval(<<'.,.,', 'parser.y', 231)
1164
1102
  def _reduce_35(val, _values, result)
1165
- if Rubyang::Xpath::Parser::DEBUG
1166
- puts '"AbbreviatedRelativeLocationPath" : "RelativeLocationPath" "//" "Step"'
1167
- puts "val: #{val.inspect}"
1168
- end
1103
+ @@logger.debug { '"AbbreviatedRelativeLocationPath" : "RelativeLocationPath" "//" "Step"' }
1104
+ @@logger.debug { "val: #{val.inspect}" }
1169
1105
  raise "AbbreviatedRelativeLocationPath is not implemented"
1170
1106
  result = val[0]
1171
1107
 
@@ -1173,12 +1109,10 @@ module_eval(<<'.,.,', 'parser.y', 297)
1173
1109
  end
1174
1110
  .,.,
1175
1111
 
1176
- module_eval(<<'.,.,', 'parser.y', 307)
1112
+ module_eval(<<'.,.,', 'parser.y', 239)
1177
1113
  def _reduce_36(val, _values, result)
1178
- if Rubyang::Xpath::Parser::DEBUG
1179
- puts '"AbbreviatedStep" : "."'
1180
- puts "val: #{val.inspect}"
1181
- end
1114
+ @@logger.debug { '"AbbreviatedStep" : "."' }
1115
+ @@logger.debug { "val: #{val.inspect}" }
1182
1116
  axis = Rubyang::Xpath::Axis.new Rubyang::Xpath::Axis::SELF
1183
1117
  node_test = Rubyang::Xpath::NodeTest.new Rubyang::Xpath::NodeTest::NodeTestType::NAME_TEST, '*'
1184
1118
  predicates = Rubyang::Xpath::Predicates.new
@@ -1188,12 +1122,10 @@ module_eval(<<'.,.,', 'parser.y', 307)
1188
1122
  end
1189
1123
  .,.,
1190
1124
 
1191
- module_eval(<<'.,.,', 'parser.y', 318)
1125
+ module_eval(<<'.,.,', 'parser.y', 248)
1192
1126
  def _reduce_37(val, _values, result)
1193
- if Rubyang::Xpath::Parser::DEBUG
1194
- puts '"AbbreviatedStep" : ".."'
1195
- puts "val: #{val.inspect}"
1196
- end
1127
+ @@logger.debug { '"AbbreviatedStep" : ".."' }
1128
+ @@logger.debug { "val: #{val.inspect}" }
1197
1129
  axis = Rubyang::Xpath::Axis.new Rubyang::Xpath::Axis::PARENT
1198
1130
  node_test = Rubyang::Xpath::NodeTest.new Rubyang::Xpath::NodeTest::NodeTestType::NODE_TYPE, Rubyang::Xpath::NodeTest::NodeType::NODE
1199
1131
  predicates = Rubyang::Xpath::Predicates.new
@@ -1203,48 +1135,40 @@ module_eval(<<'.,.,', 'parser.y', 318)
1203
1135
  end
1204
1136
  .,.,
1205
1137
 
1206
- module_eval(<<'.,.,', 'parser.y', 330)
1138
+ module_eval(<<'.,.,', 'parser.y', 258)
1207
1139
  def _reduce_38(val, _values, result)
1208
- if Rubyang::Xpath::Parser::DEBUG
1209
- puts '"AbbreviatedAxisSpecifier" : '
1210
- puts "val: #{val.inspect}"
1211
- end
1140
+ @@logger.debug { '"AbbreviatedAxisSpecifier" : ' }
1141
+ @@logger.debug { "val: #{val.inspect}" }
1212
1142
  result = Rubyang::Xpath::Axis::CHILD
1213
1143
 
1214
1144
  result
1215
1145
  end
1216
1146
  .,.,
1217
1147
 
1218
- module_eval(<<'.,.,', 'parser.y', 338)
1148
+ module_eval(<<'.,.,', 'parser.y', 264)
1219
1149
  def _reduce_39(val, _values, result)
1220
- if Rubyang::Xpath::Parser::DEBUG
1221
- puts '"AbbreviatedAxisSpecifier" : "@"'
1222
- puts "val: #{val.inspect}"
1223
- end
1150
+ @@logger.debug { '"AbbreviatedAxisSpecifier" : "@"' }
1151
+ @@logger.debug { "val: #{val.inspect}" }
1224
1152
  result = Rubyang::Xpath::Axis::ATTRIBUTE
1225
1153
 
1226
1154
  result
1227
1155
  end
1228
1156
  .,.,
1229
1157
 
1230
- module_eval(<<'.,.,', 'parser.y', 347)
1158
+ module_eval(<<'.,.,', 'parser.y', 271)
1231
1159
  def _reduce_40(val, _values, result)
1232
- if Rubyang::Xpath::Parser::DEBUG
1233
- puts '"Expr" : "OrExpr"'
1234
- puts "val: #{val.inspect}"
1235
- end
1160
+ @@logger.debug { '"Expr" : "OrExpr"' }
1161
+ @@logger.debug { "val: #{val.inspect}" }
1236
1162
  result = val[0]
1237
1163
 
1238
1164
  result
1239
1165
  end
1240
1166
  .,.,
1241
1167
 
1242
- module_eval(<<'.,.,', 'parser.y', 356)
1168
+ module_eval(<<'.,.,', 'parser.y', 278)
1243
1169
  def _reduce_41(val, _values, result)
1244
- if Rubyang::Xpath::Parser::DEBUG
1245
- puts '"PrimaryExpr" : "VariableReference"'
1246
- puts "val: #{val.inspect}"
1247
- end
1170
+ @@logger.debug { '"PrimaryExpr" : "VariableReference"' }
1171
+ @@logger.debug { "val: #{val.inspect}" }
1248
1172
  result = val[0]
1249
1173
  raise "VariableReference is not implemented"
1250
1174
 
@@ -1252,25 +1176,20 @@ module_eval(<<'.,.,', 'parser.y', 356)
1252
1176
  end
1253
1177
  .,.,
1254
1178
 
1255
- module_eval(<<'.,.,', 'parser.y', 365)
1179
+ module_eval(<<'.,.,', 'parser.y', 285)
1256
1180
  def _reduce_42(val, _values, result)
1257
- if Rubyang::Xpath::Parser::DEBUG
1258
- puts '"PrimaryExpr" : "(" "Expr" ")"'
1259
- puts "val: #{val.inspect}"
1260
- end
1181
+ @@logger.debug { '"PrimaryExpr" : "(" "Expr" ")"' }
1182
+ @@logger.debug { "val: #{val.inspect}" }
1261
1183
  result = val[1]
1262
- raise "'(' Expr ')' is not implemented"
1263
1184
 
1264
1185
  result
1265
1186
  end
1266
1187
  .,.,
1267
1188
 
1268
- module_eval(<<'.,.,', 'parser.y', 374)
1189
+ module_eval(<<'.,.,', 'parser.y', 291)
1269
1190
  def _reduce_43(val, _values, result)
1270
- if Rubyang::Xpath::Parser::DEBUG
1271
- puts '"PrimaryExpr" : "Literal"'
1272
- puts "val: #{val.inspect}"
1273
- end
1191
+ @@logger.debug { '"PrimaryExpr" : "Literal"' }
1192
+ @@logger.debug { "val: #{val.inspect}" }
1274
1193
  literal = Rubyang::Xpath::Literal.new val[0]
1275
1194
  result = Rubyang::Xpath::PrimaryExpr.new literal
1276
1195
 
@@ -1278,12 +1197,10 @@ module_eval(<<'.,.,', 'parser.y', 374)
1278
1197
  end
1279
1198
  .,.,
1280
1199
 
1281
- module_eval(<<'.,.,', 'parser.y', 383)
1200
+ module_eval(<<'.,.,', 'parser.y', 298)
1282
1201
  def _reduce_44(val, _values, result)
1283
- if Rubyang::Xpath::Parser::DEBUG
1284
- puts '"PrimaryExpr" : "Number"'
1285
- puts "val: #{val.inspect}"
1286
- end
1202
+ @@logger.debug { '"PrimaryExpr" : "Number"' }
1203
+ @@logger.debug { "val: #{val.inspect}" }
1287
1204
  number = Rubyang::Xpath::Number.new val[0]
1288
1205
  result = Rubyang::Xpath::PrimaryExpr.new number
1289
1206
 
@@ -1291,492 +1208,410 @@ module_eval(<<'.,.,', 'parser.y', 383)
1291
1208
  end
1292
1209
  .,.,
1293
1210
 
1294
- module_eval(<<'.,.,', 'parser.y', 392)
1211
+ module_eval(<<'.,.,', 'parser.y', 305)
1295
1212
  def _reduce_45(val, _values, result)
1296
- if Rubyang::Xpath::Parser::DEBUG
1297
- puts '"PrimaryExpr" : "FunctionCall"'
1298
- puts "val: #{val.inspect}"
1299
- end
1213
+ @@logger.debug { '"PrimaryExpr" : "FunctionCall"' }
1214
+ @@logger.debug { "val: #{val.inspect}" }
1300
1215
  result = Rubyang::Xpath::PrimaryExpr.new val[0]
1301
1216
 
1302
1217
  result
1303
1218
  end
1304
1219
  .,.,
1305
1220
 
1306
- module_eval(<<'.,.,', 'parser.y', 401)
1221
+ module_eval(<<'.,.,', 'parser.y', 312)
1307
1222
  def _reduce_46(val, _values, result)
1308
- if Rubyang::Xpath::Parser::DEBUG
1309
- puts '"FunctionCall" : "FunctionName(" ")"'
1310
- puts "val: #{val.inspect}"
1311
- end
1223
+ @@logger.debug { '"FunctionCall" : "FunctionName(" ")"' }
1224
+ @@logger.debug { "val: #{val.inspect}" }
1312
1225
  result = Rubyang::Xpath::FunctionCall.new val[0]
1313
1226
 
1314
1227
  result
1315
1228
  end
1316
1229
  .,.,
1317
1230
 
1318
- module_eval(<<'.,.,', 'parser.y', 409)
1231
+ module_eval(<<'.,.,', 'parser.y', 318)
1319
1232
  def _reduce_47(val, _values, result)
1320
- if Rubyang::Xpath::Parser::DEBUG
1321
- puts '"FunctionCall" : "FunctionName(" "Arguments" ")"'
1322
- puts "val: #{val.inspect}"
1323
- end
1233
+ @@logger.debug { '"FunctionCall" : "FunctionName(" "Arguments" ")"' }
1234
+ @@logger.debug { "val: #{val.inspect}" }
1324
1235
  result = Rubyang::Xpath::FunctionCall.new val[0], val[1]
1325
1236
 
1326
1237
  result
1327
1238
  end
1328
1239
  .,.,
1329
1240
 
1330
- module_eval(<<'.,.,', 'parser.y', 418)
1241
+ module_eval(<<'.,.,', 'parser.y', 325)
1331
1242
  def _reduce_48(val, _values, result)
1332
- if Rubyang::Xpath::Parser::DEBUG
1333
- puts '"Arguments" : "Argument"'
1334
- puts "val: #{val.inspect}"
1335
- end
1243
+ @@logger.debug { '"Arguments" : "Argument"' }
1244
+ @@logger.debug { "val: #{val.inspect}" }
1336
1245
  result = [val[0]]
1337
1246
 
1338
1247
  result
1339
1248
  end
1340
1249
  .,.,
1341
1250
 
1342
- module_eval(<<'.,.,', 'parser.y', 426)
1251
+ module_eval(<<'.,.,', 'parser.y', 331)
1343
1252
  def _reduce_49(val, _values, result)
1344
- if Rubyang::Xpath::Parser::DEBUG
1345
- puts '"Arguments" : "Arguments" "," "Argument"'
1346
- puts "val: #{val.inspect}"
1347
- end
1253
+ @@logger.debug { '"Arguments" : "Arguments" "," "Argument"' }
1254
+ @@logger.debug { "val: #{val.inspect}" }
1348
1255
  result = val[0] + [val[1]]
1349
1256
 
1350
1257
  result
1351
1258
  end
1352
1259
  .,.,
1353
1260
 
1354
- module_eval(<<'.,.,', 'parser.y', 435)
1261
+ module_eval(<<'.,.,', 'parser.y', 338)
1355
1262
  def _reduce_50(val, _values, result)
1356
- if Rubyang::Xpath::Parser::DEBUG
1357
- puts '"Argument" : "Exp"'
1358
- puts "val: #{val.inspect}"
1359
- end
1263
+ @@logger.debug { '"Argument" : "Exp"' }
1264
+ @@logger.debug { "val: #{val.inspect}" }
1360
1265
  result = val[0]
1361
1266
 
1362
1267
  result
1363
1268
  end
1364
1269
  .,.,
1365
1270
 
1366
- module_eval(<<'.,.,', 'parser.y', 444)
1271
+ module_eval(<<'.,.,', 'parser.y', 345)
1367
1272
  def _reduce_51(val, _values, result)
1368
- if Rubyang::Xpath::Parser::DEBUG
1369
- puts '"UnionExpr" : "PathExpr"'
1370
- puts "val: #{val.inspect}"
1371
- end
1273
+ @@logger.debug { '"UnionExpr" : "PathExpr"' }
1274
+ @@logger.debug { "val: #{val.inspect}" }
1372
1275
  result = Rubyang::Xpath::UnionExpr.new val[0]
1373
1276
 
1374
1277
  result
1375
1278
  end
1376
1279
  .,.,
1377
1280
 
1378
- module_eval(<<'.,.,', 'parser.y', 452)
1281
+ module_eval(<<'.,.,', 'parser.y', 351)
1379
1282
  def _reduce_52(val, _values, result)
1380
- if Rubyang::Xpath::Parser::DEBUG
1381
- puts '"UnionExpr" : "UnionExpr" "|" "PathExpr"'
1382
- puts "val: #{val.inspect}"
1383
- end
1283
+ @@logger.debug { '"UnionExpr" : "UnionExpr" "|" "PathExpr"' }
1284
+ @@logger.debug { "val: #{val.inspect}" }
1384
1285
  result = Rubyang::Xpath::UnionExpr.new val[0], val[1], val[2]
1385
1286
 
1386
1287
  result
1387
1288
  end
1388
1289
  .,.,
1389
1290
 
1390
- module_eval(<<'.,.,', 'parser.y', 461)
1291
+ module_eval(<<'.,.,', 'parser.y', 358)
1391
1292
  def _reduce_53(val, _values, result)
1392
- if Rubyang::Xpath::Parser::DEBUG
1393
- puts '"PathExpr" : "LocationPath"'
1394
- puts "val: #{val.inspect}"
1395
- end
1293
+ @@logger.debug { '"PathExpr" : "LocationPath"' }
1294
+ @@logger.debug { "val: #{val.inspect}" }
1396
1295
  result = Rubyang::Xpath::PathExpr.new val[0]
1397
1296
 
1398
1297
  result
1399
1298
  end
1400
1299
  .,.,
1401
1300
 
1402
- module_eval(<<'.,.,', 'parser.y', 469)
1301
+ module_eval(<<'.,.,', 'parser.y', 364)
1403
1302
  def _reduce_54(val, _values, result)
1404
- if Rubyang::Xpath::Parser::DEBUG
1405
- puts '"PathExpr" : "FilterExpr"'
1406
- puts "val: #{val.inspect}"
1407
- end
1303
+ @@logger.debug { '"PathExpr" : "FilterExpr"' }
1304
+ @@logger.debug { "val: #{val.inspect}" }
1408
1305
  result = Rubyang::Xpath::PathExpr.new val[0]
1409
1306
 
1410
1307
  result
1411
1308
  end
1412
1309
  .,.,
1413
1310
 
1414
- module_eval(<<'.,.,', 'parser.y', 477)
1311
+ module_eval(<<'.,.,', 'parser.y', 370)
1415
1312
  def _reduce_55(val, _values, result)
1416
- if Rubyang::Xpath::Parser::DEBUG
1417
- puts '"PathExpr" : "FilterExpr" "/" "RelativeLocationPath"'
1418
- puts "val: #{val.inspect}"
1419
- end
1313
+ @@logger.debug { '"PathExpr" : "FilterExpr" "/" "RelativeLocationPath"' }
1314
+ @@logger.debug { "val: #{val.inspect}" }
1420
1315
  result = Rubyang::Xpath::PathExpr.new val[0], val[1], val[2]
1421
1316
 
1422
1317
  result
1423
1318
  end
1424
1319
  .,.,
1425
1320
 
1426
- module_eval(<<'.,.,', 'parser.y', 485)
1321
+ module_eval(<<'.,.,', 'parser.y', 376)
1427
1322
  def _reduce_56(val, _values, result)
1428
- if Rubyang::Xpath::Parser::DEBUG
1429
- puts '"PathExpr" : "FilterExpr" "//" "RelativeLocationPath"'
1430
- puts "val: #{val.inspect}"
1431
- end
1323
+ @@logger.debug { '"PathExpr" : "FilterExpr" "//" "RelativeLocationPath"' }
1324
+ @@logger.debug { "val: #{val.inspect}" }
1432
1325
  result = Rubyang::Xpath::PathExpr.new val[0], val[1], val[2]
1433
1326
 
1434
1327
  result
1435
1328
  end
1436
1329
  .,.,
1437
1330
 
1438
- module_eval(<<'.,.,', 'parser.y', 494)
1331
+ module_eval(<<'.,.,', 'parser.y', 383)
1439
1332
  def _reduce_57(val, _values, result)
1440
- if Rubyang::Xpath::Parser::DEBUG
1441
- puts '"FilterExpr" : "PrimaryExpr"'
1442
- puts "val: #{val.inspect}"
1443
- end
1333
+ @@logger.debug { '"FilterExpr" : "PrimaryExpr"' }
1334
+ @@logger.debug { "val: #{val.inspect}" }
1444
1335
  result = Rubyang::Xpath::FilterExpr.new val[0]
1445
1336
 
1446
1337
  result
1447
1338
  end
1448
1339
  .,.,
1449
1340
 
1450
- module_eval(<<'.,.,', 'parser.y', 502)
1341
+ module_eval(<<'.,.,', 'parser.y', 389)
1451
1342
  def _reduce_58(val, _values, result)
1452
- if Rubyang::Xpath::Parser::DEBUG
1453
- puts '"FilterExpr" : "FilterExpr Predicat"'
1454
- puts "val: #{val.inspect}"
1455
- end
1343
+ @@logger.debug { '"FilterExpr" : "FilterExpr Predicat"' }
1344
+ @@logger.debug { "val: #{val.inspect}" }
1456
1345
  result = Rubyang::Xpath::FilterExpr.new val[0], val[1]
1457
1346
 
1458
1347
  result
1459
1348
  end
1460
1349
  .,.,
1461
1350
 
1462
- module_eval(<<'.,.,', 'parser.y', 511)
1351
+ module_eval(<<'.,.,', 'parser.y', 396)
1463
1352
  def _reduce_59(val, _values, result)
1464
- if Rubyang::Xpath::Parser::DEBUG
1465
- puts '"OrExpr" : "AndExpr"'
1466
- puts "val: #{val.inspect}"
1467
- end
1353
+ @@logger.debug { '"OrExpr" : "AndExpr"' }
1354
+ @@logger.debug { "val: #{val.inspect}" }
1468
1355
  result = Rubyang::Xpath::OrExpr.new val[0]
1469
1356
 
1470
1357
  result
1471
1358
  end
1472
1359
  .,.,
1473
1360
 
1474
- module_eval(<<'.,.,', 'parser.y', 519)
1361
+ module_eval(<<'.,.,', 'parser.y', 402)
1475
1362
  def _reduce_60(val, _values, result)
1476
- if Rubyang::Xpath::Parser::DEBUG
1477
- puts '"OrExpr" : "OrExpr" "or" "AndExpr"'
1478
- puts "val: #{val.inspect}"
1479
- end
1363
+ @@logger.debug { '"OrExpr" : "OrExpr" "or" "AndExpr"' }
1364
+ @@logger.debug { "val: #{val.inspect}" }
1480
1365
  result = Rubyang::Xpath::OrExpr.new val[0], val[2]
1481
1366
 
1482
1367
  result
1483
1368
  end
1484
1369
  .,.,
1485
1370
 
1486
- module_eval(<<'.,.,', 'parser.y', 528)
1371
+ module_eval(<<'.,.,', 'parser.y', 409)
1487
1372
  def _reduce_61(val, _values, result)
1488
- if Rubyang::Xpath::Parser::DEBUG
1489
- puts '"AndExpr" : "EqualityExpr"'
1490
- puts "val: #{val.inspect}"
1491
- end
1373
+ @@logger.debug { '"AndExpr" : "EqualityExpr"' }
1374
+ @@logger.debug { "val: #{val.inspect}" }
1492
1375
  result = Rubyang::Xpath::AndExpr.new val[0]
1493
1376
 
1494
1377
  result
1495
1378
  end
1496
1379
  .,.,
1497
1380
 
1498
- module_eval(<<'.,.,', 'parser.y', 536)
1381
+ module_eval(<<'.,.,', 'parser.y', 415)
1499
1382
  def _reduce_62(val, _values, result)
1500
- if Rubyang::Xpath::Parser::DEBUG
1501
- puts '"AndExpr" : "AndExpr" "and" "EqualityExpr"'
1502
- puts "val: #{val.inspect}"
1503
- end
1383
+ @@logger.debug { '"AndExpr" : "AndExpr" "and" "EqualityExpr"' }
1384
+ @@logger.debug { "val: #{val.inspect}" }
1504
1385
  result = Rubyang::Xpath::AndExpr.new val[0], val[2]
1505
1386
 
1506
1387
  result
1507
1388
  end
1508
1389
  .,.,
1509
1390
 
1510
- module_eval(<<'.,.,', 'parser.y', 545)
1391
+ module_eval(<<'.,.,', 'parser.y', 422)
1511
1392
  def _reduce_63(val, _values, result)
1512
- if Rubyang::Xpath::Parser::DEBUG
1513
- puts '"EqualityExpr" : "RelationalExpr"'
1514
- puts "val: #{val.inspect}"
1515
- end
1393
+ @@logger.debug { '"EqualityExpr" : "RelationalExpr"' }
1394
+ @@logger.debug { "val: #{val.inspect}" }
1516
1395
  result = Rubyang::Xpath::EqualityExpr.new val[0]
1517
1396
 
1518
1397
  result
1519
1398
  end
1520
1399
  .,.,
1521
1400
 
1522
- module_eval(<<'.,.,', 'parser.y', 553)
1401
+ module_eval(<<'.,.,', 'parser.y', 428)
1523
1402
  def _reduce_64(val, _values, result)
1524
- if Rubyang::Xpath::Parser::DEBUG
1525
- puts '"EqualityExpr" : "EqualityExpr" "=" "RelationalExpr"'
1526
- puts "val: #{val.inspect}"
1527
- end
1403
+ @@logger.debug { '"EqualityExpr" : "EqualityExpr" "=" "RelationalExpr"' }
1404
+ @@logger.debug { "val: #{val.inspect}" }
1528
1405
  result = Rubyang::Xpath::EqualityExpr.new val[0], val[1], val[2]
1529
1406
 
1530
1407
  result
1531
1408
  end
1532
1409
  .,.,
1533
1410
 
1534
- module_eval(<<'.,.,', 'parser.y', 561)
1411
+ module_eval(<<'.,.,', 'parser.y', 434)
1535
1412
  def _reduce_65(val, _values, result)
1536
- if Rubyang::Xpath::Parser::DEBUG
1537
- puts '"EqualityExpr" : "EqualityExpr" "!=" "RelationalExpr"'
1538
- puts "val: #{val.inspect}"
1539
- end
1413
+ @@logger.debug { '"EqualityExpr" : "EqualityExpr" "!=" "RelationalExpr"' }
1414
+ @@logger.debug { "val: #{val.inspect}" }
1540
1415
  result = Rubyang::Xpath::EqualityExpr.new val[0], val[1], val[2]
1541
1416
 
1542
1417
  result
1543
1418
  end
1544
1419
  .,.,
1545
1420
 
1546
- module_eval(<<'.,.,', 'parser.y', 570)
1421
+ module_eval(<<'.,.,', 'parser.y', 441)
1547
1422
  def _reduce_66(val, _values, result)
1548
- if Rubyang::Xpath::Parser::DEBUG
1549
- puts '"RelationalExpr" : "AdditiveExpr"'
1550
- puts "val: #{val.inspect}"
1551
- end
1423
+ @@logger.debug { '"RelationalExpr" : "AdditiveExpr"' }
1424
+ @@logger.debug { "val: #{val.inspect}" }
1552
1425
  result = Rubyang::Xpath::RelationalExpr.new val[0]
1553
1426
 
1554
1427
  result
1555
1428
  end
1556
1429
  .,.,
1557
1430
 
1558
- module_eval(<<'.,.,', 'parser.y', 578)
1431
+ module_eval(<<'.,.,', 'parser.y', 447)
1559
1432
  def _reduce_67(val, _values, result)
1560
- if Rubyang::Xpath::Parser::DEBUG
1561
- puts '"RelationalExpr" : "RelationalExpr" "<" "AdditiveExpr"'
1562
- puts "val: #{val.inspect}"
1563
- end
1433
+ @@logger.debug { '"RelationalExpr" : "RelationalExpr" "<" "AdditiveExpr"' }
1434
+ @@logger.debug { "val: #{val.inspect}" }
1564
1435
  result = Rubyang::Xpath::RelationalExpr.new val[0], val[1], val[2]
1565
1436
 
1566
1437
  result
1567
1438
  end
1568
1439
  .,.,
1569
1440
 
1570
- module_eval(<<'.,.,', 'parser.y', 586)
1441
+ module_eval(<<'.,.,', 'parser.y', 453)
1571
1442
  def _reduce_68(val, _values, result)
1572
- if Rubyang::Xpath::Parser::DEBUG
1573
- puts '"RelationalExpr" : "RelationalExpr" ">" "AdditiveExpr"'
1574
- puts "val: #{val.inspect}"
1575
- end
1443
+ @@logger.debug { '"RelationalExpr" : "RelationalExpr" ">" "AdditiveExpr"' }
1444
+ @@logger.debug { "val: #{val.inspect}" }
1576
1445
  result = Rubyang::Xpath::RelationalExpr.new val[0], val[1], val[2]
1577
1446
 
1578
1447
  result
1579
1448
  end
1580
1449
  .,.,
1581
1450
 
1582
- module_eval(<<'.,.,', 'parser.y', 594)
1451
+ module_eval(<<'.,.,', 'parser.y', 459)
1583
1452
  def _reduce_69(val, _values, result)
1584
- if Rubyang::Xpath::Parser::DEBUG
1585
- puts '"RelationalExpr" : "RelationalExpr" "<=" "AdditiveExpr"'
1586
- puts "val: #{val.inspect}"
1587
- end
1453
+ @@logger.debug { '"RelationalExpr" : "RelationalExpr" "<=" "AdditiveExpr"' }
1454
+ @@logger.debug { "val: #{val.inspect}" }
1588
1455
  result = Rubyang::Xpath::RelationalExpr.new val[0], val[1], val[2]
1589
1456
 
1590
1457
  result
1591
1458
  end
1592
1459
  .,.,
1593
1460
 
1594
- module_eval(<<'.,.,', 'parser.y', 602)
1461
+ module_eval(<<'.,.,', 'parser.y', 465)
1595
1462
  def _reduce_70(val, _values, result)
1596
- if Rubyang::Xpath::Parser::DEBUG
1597
- puts '"RelationalExpr" : "RelationalExpr" ">=" "AdditiveExpr"'
1598
- puts "val: #{val.inspect}"
1599
- end
1463
+ @@logger.debug { '"RelationalExpr" : "RelationalExpr" ">=" "AdditiveExpr"' }
1464
+ @@logger.debug { "val: #{val.inspect}" }
1600
1465
  result = Rubyang::Xpath::RelationalExpr.new val[0], val[1], val[2]
1601
1466
 
1602
1467
  result
1603
1468
  end
1604
1469
  .,.,
1605
1470
 
1606
- module_eval(<<'.,.,', 'parser.y', 611)
1471
+ module_eval(<<'.,.,', 'parser.y', 472)
1607
1472
  def _reduce_71(val, _values, result)
1608
- if Rubyang::Xpath::Parser::DEBUG
1609
- puts '"AdditiveExpr" : "MultiplicativeExpr"'
1610
- puts "val: #{val.inspect}"
1611
- end
1473
+ @@logger.debug { '"AdditiveExpr" : "MultiplicativeExpr"' }
1474
+ @@logger.debug { "val: #{val.inspect}" }
1612
1475
  result = Rubyang::Xpath::AdditiveExpr.new val[0]
1613
1476
 
1614
1477
  result
1615
1478
  end
1616
1479
  .,.,
1617
1480
 
1618
- module_eval(<<'.,.,', 'parser.y', 619)
1481
+ module_eval(<<'.,.,', 'parser.y', 478)
1619
1482
  def _reduce_72(val, _values, result)
1620
- if Rubyang::Xpath::Parser::DEBUG
1621
- puts '"AdditiveExpr" : "AdditiveExpr" "+" "MultiplicativeExpr"'
1622
- puts "val: #{val.inspect}"
1623
- end
1483
+ @@logger.debug { '"AdditiveExpr" : "AdditiveExpr" "+" "MultiplicativeExpr"' }
1484
+ @@logger.debug { "val: #{val.inspect}" }
1624
1485
  result = Rubyang::Xpath::AdditiveExpr.new val[0], val[1], val[2]
1625
1486
 
1626
1487
  result
1627
1488
  end
1628
1489
  .,.,
1629
1490
 
1630
- module_eval(<<'.,.,', 'parser.y', 627)
1491
+ module_eval(<<'.,.,', 'parser.y', 484)
1631
1492
  def _reduce_73(val, _values, result)
1632
- if Rubyang::Xpath::Parser::DEBUG
1633
- puts '"AdditiveExpr" : "AdditiveExpr" "-" "MultiplicativeExpr"'
1634
- puts "val: #{val.inspect}"
1635
- end
1493
+ @@logger.debug { '"AdditiveExpr" : "AdditiveExpr" "-" "MultiplicativeExpr"' }
1494
+ @@logger.debug { "val: #{val.inspect}" }
1636
1495
  result = Rubyang::Xpath::AdditiveExpr.new val[0], val[1], val[2]
1637
1496
 
1638
1497
  result
1639
1498
  end
1640
1499
  .,.,
1641
1500
 
1642
- module_eval(<<'.,.,', 'parser.y', 636)
1501
+ module_eval(<<'.,.,', 'parser.y', 491)
1643
1502
  def _reduce_74(val, _values, result)
1644
- if Rubyang::Xpath::Parser::DEBUG
1645
- puts '"MultiplicativeExpr" : "UnaryExpr"'
1646
- puts "val: #{val.inspect}"
1647
- end
1503
+ @@logger.debug { '"MultiplicativeExpr" : "UnaryExpr"' }
1504
+ @@logger.debug { "val: #{val.inspect}" }
1648
1505
  result = Rubyang::Xpath::MultiplicativeExpr.new val[0]
1649
1506
 
1650
1507
  result
1651
1508
  end
1652
1509
  .,.,
1653
1510
 
1654
- module_eval(<<'.,.,', 'parser.y', 644)
1511
+ module_eval(<<'.,.,', 'parser.y', 497)
1655
1512
  def _reduce_75(val, _values, result)
1656
- if Rubyang::Xpath::Parser::DEBUG
1657
- puts '"MultiplicativeExpr" : "MultiplicativeExpr" "*" "UnaryExpr"'
1658
- puts "val: #{val.inspect}"
1659
- end
1513
+ @@logger.debug { '"MultiplicativeExpr" : "MultiplicativeExpr" "*" "UnaryExpr"' }
1514
+ @@logger.debug { "val: #{val.inspect}" }
1660
1515
  result = Rubyang::Xpath::MultiplicativeExpr.new val[0], val[1], val[2]
1661
1516
 
1662
1517
  result
1663
1518
  end
1664
1519
  .,.,
1665
1520
 
1666
- module_eval(<<'.,.,', 'parser.y', 652)
1521
+ module_eval(<<'.,.,', 'parser.y', 503)
1667
1522
  def _reduce_76(val, _values, result)
1668
- if Rubyang::Xpath::Parser::DEBUG
1669
- puts '"MultiplicativeExpr" : "MultiplicativeExpr" "div" "UnaryExpr"'
1670
- puts "val: #{val.inspect}"
1671
- end
1523
+ @@logger.debug { '"MultiplicativeExpr" : "MultiplicativeExpr" "div" "UnaryExpr"' }
1524
+ @@logger.debug { "val: #{val.inspect}" }
1672
1525
  result = Rubyang::Xpath::MultiplicativeExpr.new val[0], val[1], val[2]
1673
1526
 
1674
1527
  result
1675
1528
  end
1676
1529
  .,.,
1677
1530
 
1678
- module_eval(<<'.,.,', 'parser.y', 660)
1531
+ module_eval(<<'.,.,', 'parser.y', 509)
1679
1532
  def _reduce_77(val, _values, result)
1680
- if Rubyang::Xpath::Parser::DEBUG
1681
- puts '"MultiplicativeExpr" : "MultiplicativeExpr" "mod" "UnaryExpr"'
1682
- puts "val: #{val.inspect}"
1683
- end
1533
+ @@logger.debug { '"MultiplicativeExpr" : "MultiplicativeExpr" "mod" "UnaryExpr"' }
1534
+ @@logger.debug { "val: #{val.inspect}" }
1684
1535
  result = Rubyang::Xpath::MultiplicativeExpr.new val[0], val[1], val[2]
1685
1536
 
1686
1537
  result
1687
1538
  end
1688
1539
  .,.,
1689
1540
 
1690
- module_eval(<<'.,.,', 'parser.y', 669)
1541
+ module_eval(<<'.,.,', 'parser.y', 516)
1691
1542
  def _reduce_78(val, _values, result)
1692
- if Rubyang::Xpath::Parser::DEBUG
1693
- puts '"UnaryExp" : "UnionExpr"'
1694
- puts "val: #{val.inspect}"
1695
- end
1543
+ @@logger.debug { '"UnaryExp" : "UnionExpr"' }
1544
+ @@logger.debug { "val: #{val.inspect}" }
1696
1545
  result = Rubyang::Xpath::UnaryExpr.new val[0]
1697
1546
 
1698
1547
  result
1699
1548
  end
1700
1549
  .,.,
1701
1550
 
1702
- module_eval(<<'.,.,', 'parser.y', 677)
1551
+ module_eval(<<'.,.,', 'parser.y', 522)
1703
1552
  def _reduce_79(val, _values, result)
1704
- if Rubyang::Xpath::Parser::DEBUG
1705
- puts '"UnaryExp" : "-" "UnaryExp"'
1706
- puts "val: #{val.inspect}"
1707
- end
1553
+ @@logger.debug { '"UnaryExp" : "-" "UnaryExp"' }
1554
+ @@logger.debug { "val: #{val.inspect}" }
1708
1555
  result = Rubyang::Xpath::UnaryExpr.new val[1], val[0]
1709
1556
 
1710
1557
  result
1711
1558
  end
1712
1559
  .,.,
1713
1560
 
1714
- module_eval(<<'.,.,', 'parser.y', 686)
1561
+ module_eval(<<'.,.,', 'parser.y', 529)
1715
1562
  def _reduce_80(val, _values, result)
1716
- if Rubyang::Xpath::Parser::DEBUG
1717
- puts '"Number" : "Digits"'
1718
- puts "val: #{val.inspect}"
1719
- end
1563
+ @@logger.debug { '"Number" : "Digits"' }
1564
+ @@logger.debug { "val: #{val.inspect}" }
1720
1565
  result = val[0]
1721
1566
 
1722
1567
  result
1723
1568
  end
1724
1569
  .,.,
1725
1570
 
1726
- module_eval(<<'.,.,', 'parser.y', 694)
1571
+ module_eval(<<'.,.,', 'parser.y', 535)
1727
1572
  def _reduce_81(val, _values, result)
1728
- if Rubyang::Xpath::Parser::DEBUG
1729
- puts '"Number" : "Digits" "."'
1730
- puts "val: #{val.inspect}"
1731
- end
1573
+ @@logger.debug { '"Number" : "Digits" "."' }
1574
+ @@logger.debug { "val: #{val.inspect}" }
1732
1575
  result = val[0]
1733
1576
 
1734
1577
  result
1735
1578
  end
1736
1579
  .,.,
1737
1580
 
1738
- module_eval(<<'.,.,', 'parser.y', 702)
1581
+ module_eval(<<'.,.,', 'parser.y', 541)
1739
1582
  def _reduce_82(val, _values, result)
1740
- if Rubyang::Xpath::Parser::DEBUG
1741
- puts '"Number" : "Digits" "." "Digits"'
1742
- puts "val: #{val.inspect}"
1743
- end
1583
+ @@logger.debug { '"Number" : "Digits" "." "Digits"' }
1584
+ @@logger.debug { "val: #{val.inspect}" }
1744
1585
  result = val[0] + val[1] + val[2]
1745
1586
 
1746
1587
  result
1747
1588
  end
1748
1589
  .,.,
1749
1590
 
1750
- module_eval(<<'.,.,', 'parser.y', 710)
1591
+ module_eval(<<'.,.,', 'parser.y', 547)
1751
1592
  def _reduce_83(val, _values, result)
1752
- if Rubyang::Xpath::Parser::DEBUG
1753
- puts '"Number" : "." "Digits"'
1754
- puts "val: #{val.inspect}"
1755
- end
1593
+ @@logger.debug { '"Number" : "." "Digits"' }
1594
+ @@logger.debug { "val: #{val.inspect}" }
1756
1595
  result = "0" + val[1] + val[2]
1757
1596
 
1758
1597
  result
1759
1598
  end
1760
1599
  .,.,
1761
1600
 
1762
- module_eval(<<'.,.,', 'parser.y', 719)
1601
+ module_eval(<<'.,.,', 'parser.y', 554)
1763
1602
  def _reduce_84(val, _values, result)
1764
- if Rubyang::Xpath::Parser::DEBUG
1765
- puts '"FunctionName(" : "last("'
1766
- puts "val: #{val.inspect}"
1767
- end
1603
+ @@logger.debug { '"FunctionName(" : "last("' }
1604
+ @@logger.debug { "val: #{val.inspect}" }
1768
1605
  result = Rubyang::Xpath::FunctionCall::LAST
1769
1606
 
1770
1607
  result
1771
1608
  end
1772
1609
  .,.,
1773
1610
 
1774
- module_eval(<<'.,.,', 'parser.y', 727)
1611
+ module_eval(<<'.,.,', 'parser.y', 560)
1775
1612
  def _reduce_85(val, _values, result)
1776
- if Rubyang::Xpath::Parser::DEBUG
1777
- puts '"FunctionName(" : "position("'
1778
- puts "val: #{val.inspect}"
1779
- end
1613
+ @@logger.debug { '"FunctionName(" : "position("' }
1614
+ @@logger.debug { "val: #{val.inspect}" }
1780
1615
  result = Rubyang::Xpath::FunctionCall::LAST
1781
1616
  result = val[0]
1782
1617
 
@@ -1784,12 +1619,10 @@ module_eval(<<'.,.,', 'parser.y', 727)
1784
1619
  end
1785
1620
  .,.,
1786
1621
 
1787
- module_eval(<<'.,.,', 'parser.y', 736)
1622
+ module_eval(<<'.,.,', 'parser.y', 567)
1788
1623
  def _reduce_86(val, _values, result)
1789
- if Rubyang::Xpath::Parser::DEBUG
1790
- puts '"FunctionName(" : "count("'
1791
- puts "val: #{val.inspect}"
1792
- end
1624
+ @@logger.debug { '"FunctionName(" : "count("' }
1625
+ @@logger.debug { "val: #{val.inspect}" }
1793
1626
  result = Rubyang::Xpath::FunctionCall::LAST
1794
1627
  result = val[0]
1795
1628
 
@@ -1797,12 +1630,10 @@ module_eval(<<'.,.,', 'parser.y', 736)
1797
1630
  end
1798
1631
  .,.,
1799
1632
 
1800
- module_eval(<<'.,.,', 'parser.y', 745)
1633
+ module_eval(<<'.,.,', 'parser.y', 574)
1801
1634
  def _reduce_87(val, _values, result)
1802
- if Rubyang::Xpath::Parser::DEBUG
1803
- puts '"FunctionName(" : "id("'
1804
- puts "val: #{val.inspect}"
1805
- end
1635
+ @@logger.debug { '"FunctionName(" : "id("' }
1636
+ @@logger.debug { "val: #{val.inspect}" }
1806
1637
  result = Rubyang::Xpath::FunctionCall::LAST
1807
1638
  result = val[0]
1808
1639
 
@@ -1810,12 +1641,10 @@ module_eval(<<'.,.,', 'parser.y', 745)
1810
1641
  end
1811
1642
  .,.,
1812
1643
 
1813
- module_eval(<<'.,.,', 'parser.y', 754)
1644
+ module_eval(<<'.,.,', 'parser.y', 581)
1814
1645
  def _reduce_88(val, _values, result)
1815
- if Rubyang::Xpath::Parser::DEBUG
1816
- puts '"FunctionName(" : "local-name("'
1817
- puts "val: #{val.inspect}"
1818
- end
1646
+ @@logger.debug { '"FunctionName(" : "local-name("' }
1647
+ @@logger.debug { "val: #{val.inspect}" }
1819
1648
  result = val[0]
1820
1649
  result = Rubyang::Xpath::FunctionCall::LAST
1821
1650
 
@@ -1823,12 +1652,10 @@ module_eval(<<'.,.,', 'parser.y', 754)
1823
1652
  end
1824
1653
  .,.,
1825
1654
 
1826
- module_eval(<<'.,.,', 'parser.y', 763)
1655
+ module_eval(<<'.,.,', 'parser.y', 588)
1827
1656
  def _reduce_89(val, _values, result)
1828
- if Rubyang::Xpath::Parser::DEBUG
1829
- puts '"FunctionName(" : "namespace-uri("'
1830
- puts "val: #{val.inspect}"
1831
- end
1657
+ @@logger.debug { '"FunctionName(" : "namespace-uri("' }
1658
+ @@logger.debug { "val: #{val.inspect}" }
1832
1659
  result = val[0]
1833
1660
  result = Rubyang::Xpath::FunctionCall::LAST
1834
1661
 
@@ -1836,12 +1663,10 @@ module_eval(<<'.,.,', 'parser.y', 763)
1836
1663
  end
1837
1664
  .,.,
1838
1665
 
1839
- module_eval(<<'.,.,', 'parser.y', 772)
1666
+ module_eval(<<'.,.,', 'parser.y', 595)
1840
1667
  def _reduce_90(val, _values, result)
1841
- if Rubyang::Xpath::Parser::DEBUG
1842
- puts '"FunctionName(" : "name("'
1843
- puts "val: #{val.inspect}"
1844
- end
1668
+ @@logger.debug { '"FunctionName(" : "name("' }
1669
+ @@logger.debug { "val: #{val.inspect}" }
1845
1670
  result = val[0]
1846
1671
  result = Rubyang::Xpath::FunctionCall::LAST
1847
1672
 
@@ -1849,12 +1674,10 @@ module_eval(<<'.,.,', 'parser.y', 772)
1849
1674
  end
1850
1675
  .,.,
1851
1676
 
1852
- module_eval(<<'.,.,', 'parser.y', 781)
1677
+ module_eval(<<'.,.,', 'parser.y', 602)
1853
1678
  def _reduce_91(val, _values, result)
1854
- if Rubyang::Xpath::Parser::DEBUG
1855
- puts '"FunctionName(" : "string("'
1856
- puts "val: #{val.inspect}"
1857
- end
1679
+ @@logger.debug { '"FunctionName(" : "string("' }
1680
+ @@logger.debug { "val: #{val.inspect}" }
1858
1681
  result = val[0]
1859
1682
  result = Rubyang::Xpath::FunctionCall::LAST
1860
1683
 
@@ -1862,12 +1685,10 @@ module_eval(<<'.,.,', 'parser.y', 781)
1862
1685
  end
1863
1686
  .,.,
1864
1687
 
1865
- module_eval(<<'.,.,', 'parser.y', 790)
1688
+ module_eval(<<'.,.,', 'parser.y', 609)
1866
1689
  def _reduce_92(val, _values, result)
1867
- if Rubyang::Xpath::Parser::DEBUG
1868
- puts '"FunctionName(" : "concat("'
1869
- puts "val: #{val.inspect}"
1870
- end
1690
+ @@logger.debug { '"FunctionName(" : "concat("' }
1691
+ @@logger.debug { "val: #{val.inspect}" }
1871
1692
  result = val[0]
1872
1693
  result = Rubyang::Xpath::FunctionCall::LAST
1873
1694
 
@@ -1875,12 +1696,10 @@ module_eval(<<'.,.,', 'parser.y', 790)
1875
1696
  end
1876
1697
  .,.,
1877
1698
 
1878
- module_eval(<<'.,.,', 'parser.y', 799)
1699
+ module_eval(<<'.,.,', 'parser.y', 616)
1879
1700
  def _reduce_93(val, _values, result)
1880
- if Rubyang::Xpath::Parser::DEBUG
1881
- puts '"FunctionName(" : "starts-with("'
1882
- puts "val: #{val.inspect}"
1883
- end
1701
+ @@logger.debug { '"FunctionName(" : "starts-with("' }
1702
+ @@logger.debug { "val: #{val.inspect}" }
1884
1703
  result = val[0]
1885
1704
  result = Rubyang::Xpath::FunctionCall::LAST
1886
1705
 
@@ -1888,12 +1707,10 @@ module_eval(<<'.,.,', 'parser.y', 799)
1888
1707
  end
1889
1708
  .,.,
1890
1709
 
1891
- module_eval(<<'.,.,', 'parser.y', 808)
1710
+ module_eval(<<'.,.,', 'parser.y', 623)
1892
1711
  def _reduce_94(val, _values, result)
1893
- if Rubyang::Xpath::Parser::DEBUG
1894
- puts '"FunctionName(" : "contains("'
1895
- puts "val: #{val.inspect}"
1896
- end
1712
+ @@logger.debug { '"FunctionName(" : "contains("' }
1713
+ @@logger.debug { "val: #{val.inspect}" }
1897
1714
  result = val[0]
1898
1715
  result = Rubyang::Xpath::FunctionCall::LAST
1899
1716
 
@@ -1901,12 +1718,10 @@ module_eval(<<'.,.,', 'parser.y', 808)
1901
1718
  end
1902
1719
  .,.,
1903
1720
 
1904
- module_eval(<<'.,.,', 'parser.y', 817)
1721
+ module_eval(<<'.,.,', 'parser.y', 630)
1905
1722
  def _reduce_95(val, _values, result)
1906
- if Rubyang::Xpath::Parser::DEBUG
1907
- puts '"FunctionName(" : "substring-before("'
1908
- puts "val: #{val.inspect}"
1909
- end
1723
+ @@logger.debug { '"FunctionName(" : "substring-before("' }
1724
+ @@logger.debug { "val: #{val.inspect}" }
1910
1725
  result = val[0]
1911
1726
  result = Rubyang::Xpath::FunctionCall::LAST
1912
1727
 
@@ -1914,12 +1729,10 @@ module_eval(<<'.,.,', 'parser.y', 817)
1914
1729
  end
1915
1730
  .,.,
1916
1731
 
1917
- module_eval(<<'.,.,', 'parser.y', 826)
1732
+ module_eval(<<'.,.,', 'parser.y', 637)
1918
1733
  def _reduce_96(val, _values, result)
1919
- if Rubyang::Xpath::Parser::DEBUG
1920
- puts '"FunctionName(" : "substring-after("'
1921
- puts "val: #{val.inspect}"
1922
- end
1734
+ @@logger.debug { '"FunctionName(" : "substring-after("' }
1735
+ @@logger.debug { "val: #{val.inspect}" }
1923
1736
  result = val[0]
1924
1737
  result = Rubyang::Xpath::FunctionCall::LAST
1925
1738
 
@@ -1927,12 +1740,10 @@ module_eval(<<'.,.,', 'parser.y', 826)
1927
1740
  end
1928
1741
  .,.,
1929
1742
 
1930
- module_eval(<<'.,.,', 'parser.y', 835)
1743
+ module_eval(<<'.,.,', 'parser.y', 644)
1931
1744
  def _reduce_97(val, _values, result)
1932
- if Rubyang::Xpath::Parser::DEBUG
1933
- puts '"FunctionName(" : "substring("'
1934
- puts "val: #{val.inspect}"
1935
- end
1745
+ @@logger.debug { '"FunctionName(" : "substring("' }
1746
+ @@logger.debug { "val: #{val.inspect}" }
1936
1747
  result = val[0]
1937
1748
  result = Rubyang::Xpath::FunctionCall::LAST
1938
1749
 
@@ -1940,12 +1751,10 @@ module_eval(<<'.,.,', 'parser.y', 835)
1940
1751
  end
1941
1752
  .,.,
1942
1753
 
1943
- module_eval(<<'.,.,', 'parser.y', 844)
1754
+ module_eval(<<'.,.,', 'parser.y', 651)
1944
1755
  def _reduce_98(val, _values, result)
1945
- if Rubyang::Xpath::Parser::DEBUG
1946
- puts '"FunctionName(" : "string-length("'
1947
- puts "val: #{val.inspect}"
1948
- end
1756
+ @@logger.debug { '"FunctionName(" : "string-length("' }
1757
+ @@logger.debug { "val: #{val.inspect}" }
1949
1758
  result = val[0]
1950
1759
  result = Rubyang::Xpath::FunctionCall::LAST
1951
1760
 
@@ -1953,12 +1762,10 @@ module_eval(<<'.,.,', 'parser.y', 844)
1953
1762
  end
1954
1763
  .,.,
1955
1764
 
1956
- module_eval(<<'.,.,', 'parser.y', 853)
1765
+ module_eval(<<'.,.,', 'parser.y', 658)
1957
1766
  def _reduce_99(val, _values, result)
1958
- if Rubyang::Xpath::Parser::DEBUG
1959
- puts '"FunctionName(" : "normalize-space("'
1960
- puts "val: #{val.inspect}"
1961
- end
1767
+ @@logger.debug { '"FunctionName(" : "normalize-space("' }
1768
+ @@logger.debug { "val: #{val.inspect}" }
1962
1769
  result = val[0]
1963
1770
  result = Rubyang::Xpath::FunctionCall::LAST
1964
1771
 
@@ -1966,12 +1773,10 @@ module_eval(<<'.,.,', 'parser.y', 853)
1966
1773
  end
1967
1774
  .,.,
1968
1775
 
1969
- module_eval(<<'.,.,', 'parser.y', 862)
1776
+ module_eval(<<'.,.,', 'parser.y', 665)
1970
1777
  def _reduce_100(val, _values, result)
1971
- if Rubyang::Xpath::Parser::DEBUG
1972
- puts '"FunctionName(" : "translate("'
1973
- puts "val: #{val.inspect}"
1974
- end
1778
+ @@logger.debug { '"FunctionName(" : "translate("' }
1779
+ @@logger.debug { "val: #{val.inspect}" }
1975
1780
  result = val[0]
1976
1781
  result = Rubyang::Xpath::FunctionCall::LAST
1977
1782
 
@@ -1979,12 +1784,10 @@ module_eval(<<'.,.,', 'parser.y', 862)
1979
1784
  end
1980
1785
  .,.,
1981
1786
 
1982
- module_eval(<<'.,.,', 'parser.y', 871)
1787
+ module_eval(<<'.,.,', 'parser.y', 672)
1983
1788
  def _reduce_101(val, _values, result)
1984
- if Rubyang::Xpath::Parser::DEBUG
1985
- puts '"FunctionName(" : "boolean("'
1986
- puts "val: #{val.inspect}"
1987
- end
1789
+ @@logger.debug { '"FunctionName(" : "boolean("' }
1790
+ @@logger.debug { "val: #{val.inspect}" }
1988
1791
  result = val[0]
1989
1792
  result = Rubyang::Xpath::FunctionCall::LAST
1990
1793
 
@@ -1992,12 +1795,10 @@ module_eval(<<'.,.,', 'parser.y', 871)
1992
1795
  end
1993
1796
  .,.,
1994
1797
 
1995
- module_eval(<<'.,.,', 'parser.y', 880)
1798
+ module_eval(<<'.,.,', 'parser.y', 679)
1996
1799
  def _reduce_102(val, _values, result)
1997
- if Rubyang::Xpath::Parser::DEBUG
1998
- puts '"FunctionName(" : "not("'
1999
- puts "val: #{val.inspect}"
2000
- end
1800
+ @@logger.debug { '"FunctionName(" : "not("' }
1801
+ @@logger.debug { "val: #{val.inspect}" }
2001
1802
  result = val[0]
2002
1803
  result = Rubyang::Xpath::FunctionCall::LAST
2003
1804
 
@@ -2005,12 +1806,10 @@ module_eval(<<'.,.,', 'parser.y', 880)
2005
1806
  end
2006
1807
  .,.,
2007
1808
 
2008
- module_eval(<<'.,.,', 'parser.y', 889)
1809
+ module_eval(<<'.,.,', 'parser.y', 686)
2009
1810
  def _reduce_103(val, _values, result)
2010
- if Rubyang::Xpath::Parser::DEBUG
2011
- puts '"FunctionName(" : "true("'
2012
- puts "val: #{val.inspect}"
2013
- end
1811
+ @@logger.debug { '"FunctionName(" : "true("' }
1812
+ @@logger.debug { "val: #{val.inspect}" }
2014
1813
  result = val[0]
2015
1814
  result = Rubyang::Xpath::FunctionCall::LAST
2016
1815
 
@@ -2018,12 +1817,10 @@ module_eval(<<'.,.,', 'parser.y', 889)
2018
1817
  end
2019
1818
  .,.,
2020
1819
 
2021
- module_eval(<<'.,.,', 'parser.y', 898)
1820
+ module_eval(<<'.,.,', 'parser.y', 693)
2022
1821
  def _reduce_104(val, _values, result)
2023
- if Rubyang::Xpath::Parser::DEBUG
2024
- puts '"FunctionName(" : "false("'
2025
- puts "val: #{val.inspect}"
2026
- end
1822
+ @@logger.debug { '"FunctionName(" : "false("' }
1823
+ @@logger.debug { "val: #{val.inspect}" }
2027
1824
  result = val[0]
2028
1825
  result = Rubyang::Xpath::FunctionCall::LAST
2029
1826
 
@@ -2031,12 +1828,10 @@ module_eval(<<'.,.,', 'parser.y', 898)
2031
1828
  end
2032
1829
  .,.,
2033
1830
 
2034
- module_eval(<<'.,.,', 'parser.y', 907)
1831
+ module_eval(<<'.,.,', 'parser.y', 700)
2035
1832
  def _reduce_105(val, _values, result)
2036
- if Rubyang::Xpath::Parser::DEBUG
2037
- puts '"FunctionName(" : "lang("'
2038
- puts "val: #{val.inspect}"
2039
- end
1833
+ @@logger.debug { '"FunctionName(" : "lang("' }
1834
+ @@logger.debug { "val: #{val.inspect}" }
2040
1835
  result = val[0]
2041
1836
  result = Rubyang::Xpath::FunctionCall::LAST
2042
1837
 
@@ -2044,12 +1839,10 @@ module_eval(<<'.,.,', 'parser.y', 907)
2044
1839
  end
2045
1840
  .,.,
2046
1841
 
2047
- module_eval(<<'.,.,', 'parser.y', 916)
1842
+ module_eval(<<'.,.,', 'parser.y', 707)
2048
1843
  def _reduce_106(val, _values, result)
2049
- if Rubyang::Xpath::Parser::DEBUG
2050
- puts '"FunctionName(" : "number("'
2051
- puts "val: #{val.inspect}"
2052
- end
1844
+ @@logger.debug { '"FunctionName(" : "number("' }
1845
+ @@logger.debug { "val: #{val.inspect}" }
2053
1846
  result = val[0]
2054
1847
  result = Rubyang::Xpath::FunctionCall::LAST
2055
1848
 
@@ -2057,12 +1850,10 @@ module_eval(<<'.,.,', 'parser.y', 916)
2057
1850
  end
2058
1851
  .,.,
2059
1852
 
2060
- module_eval(<<'.,.,', 'parser.y', 925)
1853
+ module_eval(<<'.,.,', 'parser.y', 714)
2061
1854
  def _reduce_107(val, _values, result)
2062
- if Rubyang::Xpath::Parser::DEBUG
2063
- puts '"FunctionName(" : "sum("'
2064
- puts "val: #{val.inspect}"
2065
- end
1855
+ @@logger.debug { '"FunctionName(" : "sum("' }
1856
+ @@logger.debug { "val: #{val.inspect}" }
2066
1857
  result = val[0]
2067
1858
  result = Rubyang::Xpath::FunctionCall::LAST
2068
1859
 
@@ -2070,12 +1861,10 @@ module_eval(<<'.,.,', 'parser.y', 925)
2070
1861
  end
2071
1862
  .,.,
2072
1863
 
2073
- module_eval(<<'.,.,', 'parser.y', 934)
1864
+ module_eval(<<'.,.,', 'parser.y', 721)
2074
1865
  def _reduce_108(val, _values, result)
2075
- if Rubyang::Xpath::Parser::DEBUG
2076
- puts '"FunctionName(" : "floor("'
2077
- puts "val: #{val.inspect}"
2078
- end
1866
+ @@logger.debug { '"FunctionName(" : "floor("' }
1867
+ @@logger.debug { "val: #{val.inspect}" }
2079
1868
  result = val[0]
2080
1869
  result = Rubyang::Xpath::FunctionCall::LAST
2081
1870
 
@@ -2083,12 +1872,10 @@ module_eval(<<'.,.,', 'parser.y', 934)
2083
1872
  end
2084
1873
  .,.,
2085
1874
 
2086
- module_eval(<<'.,.,', 'parser.y', 943)
1875
+ module_eval(<<'.,.,', 'parser.y', 728)
2087
1876
  def _reduce_109(val, _values, result)
2088
- if Rubyang::Xpath::Parser::DEBUG
2089
- puts '"FunctionName(" : "ceiling("'
2090
- puts "val: #{val.inspect}"
2091
- end
1877
+ @@logger.debug { '"FunctionName(" : "ceiling("' }
1878
+ @@logger.debug { "val: #{val.inspect}" }
2092
1879
  result = val[0]
2093
1880
  result = Rubyang::Xpath::FunctionCall::LAST
2094
1881
 
@@ -2096,12 +1883,10 @@ module_eval(<<'.,.,', 'parser.y', 943)
2096
1883
  end
2097
1884
  .,.,
2098
1885
 
2099
- module_eval(<<'.,.,', 'parser.y', 952)
1886
+ module_eval(<<'.,.,', 'parser.y', 735)
2100
1887
  def _reduce_110(val, _values, result)
2101
- if Rubyang::Xpath::Parser::DEBUG
2102
- puts '"FunctionName(" : "round("'
2103
- puts "val: #{val.inspect}"
2104
- end
1888
+ @@logger.debug { '"FunctionName(" : "round("' }
1889
+ @@logger.debug { "val: #{val.inspect}" }
2105
1890
  result = val[0]
2106
1891
  result = Rubyang::Xpath::FunctionCall::LAST
2107
1892
 
@@ -2109,168 +1894,140 @@ module_eval(<<'.,.,', 'parser.y', 952)
2109
1894
  end
2110
1895
  .,.,
2111
1896
 
2112
- module_eval(<<'.,.,', 'parser.y', 961)
1897
+ module_eval(<<'.,.,', 'parser.y', 742)
2113
1898
  def _reduce_111(val, _values, result)
2114
- if Rubyang::Xpath::Parser::DEBUG
2115
- puts '"FunctionName(" : "current("'
2116
- puts "val: #{val.inspect}"
2117
- end
1899
+ @@logger.debug { '"FunctionName(" : "current("' }
1900
+ @@logger.debug { "val: #{val.inspect}" }
2118
1901
  result = Rubyang::Xpath::FunctionCall::CURRENT
2119
1902
 
2120
1903
  result
2121
1904
  end
2122
1905
  .,.,
2123
1906
 
2124
- module_eval(<<'.,.,', 'parser.y', 970)
1907
+ module_eval(<<'.,.,', 'parser.y', 749)
2125
1908
  def _reduce_112(val, _values, result)
2126
- if Rubyang::Xpath::Parser::DEBUG
2127
- puts '"VariableReference" : "$" "QName"'
2128
- puts "val: #{val.inspect}"
2129
- end
1909
+ @@logger.debug { '"VariableReference" : "$" "QName"' }
1910
+ @@logger.debug { "val: #{val.inspect}" }
2130
1911
  result = val[0]
2131
1912
 
2132
1913
  result
2133
1914
  end
2134
1915
  .,.,
2135
1916
 
2136
- module_eval(<<'.,.,', 'parser.y', 979)
1917
+ module_eval(<<'.,.,', 'parser.y', 756)
2137
1918
  def _reduce_113(val, _values, result)
2138
- if Rubyang::Xpath::Parser::DEBUG
2139
- puts '"NameTest" : "*"'
2140
- puts "val: #{val.inspect}"
2141
- end
1919
+ @@logger.debug { '"NameTest" : "*"' }
1920
+ @@logger.debug { "val: #{val.inspect}" }
2142
1921
  Rubyang::Xpath::NodeTest::NameTest.new '*'
2143
1922
 
2144
1923
  result
2145
1924
  end
2146
1925
  .,.,
2147
1926
 
2148
- module_eval(<<'.,.,', 'parser.y', 987)
1927
+ module_eval(<<'.,.,', 'parser.y', 762)
2149
1928
  def _reduce_114(val, _values, result)
2150
- if Rubyang::Xpath::Parser::DEBUG
2151
- puts '"NameTest" : "NCName" ":" "*"'
2152
- puts "val: #{val.inspect}"
2153
- end
1929
+ @@logger.debug { '"NameTest" : "NCName" ":" "*"' }
1930
+ @@logger.debug { "val: #{val.inspect}" }
2154
1931
  Rubyang::Xpath::NodeTest::NameTest.new "#{val[0]}:*"
2155
1932
 
2156
1933
  result
2157
1934
  end
2158
1935
  .,.,
2159
1936
 
2160
- module_eval(<<'.,.,', 'parser.y', 995)
1937
+ module_eval(<<'.,.,', 'parser.y', 768)
2161
1938
  def _reduce_115(val, _values, result)
2162
- if Rubyang::Xpath::Parser::DEBUG
2163
- puts '"NameTest" : "QName"'
2164
- puts "val: #{val.inspect}"
2165
- end
1939
+ @@logger.debug { '"NameTest" : "QName"' }
1940
+ @@logger.debug { "val: #{val.inspect}" }
2166
1941
  Rubyang::Xpath::NodeTest::NameTest.new val[0]
2167
1942
 
2168
1943
  result
2169
1944
  end
2170
1945
  .,.,
2171
1946
 
2172
- module_eval(<<'.,.,', 'parser.y', 1004)
1947
+ module_eval(<<'.,.,', 'parser.y', 775)
2173
1948
  def _reduce_116(val, _values, result)
2174
- if Rubyang::Xpath::Parser::DEBUG
2175
- puts '"NodeType" : "comment"'
2176
- puts "val: #{val.inspect}"
2177
- end
1949
+ @@logger.debug { '"NodeType" : "comment"' }
1950
+ @@logger.debug { "val: #{val.inspect}" }
2178
1951
  Rubyang::Xpath::NodeTest::NodeType::COMMENT
2179
1952
 
2180
1953
  result
2181
1954
  end
2182
1955
  .,.,
2183
1956
 
2184
- module_eval(<<'.,.,', 'parser.y', 1012)
1957
+ module_eval(<<'.,.,', 'parser.y', 781)
2185
1958
  def _reduce_117(val, _values, result)
2186
- if Rubyang::Xpath::Parser::DEBUG
2187
- puts '"NodeType" : "text"'
2188
- puts "val: #{val.inspect}"
2189
- end
1959
+ @@logger.debug { '"NodeType" : "text"' }
1960
+ @@logger.debug { "val: #{val.inspect}" }
2190
1961
  Rubyang::Xpath::NodeTest::NodeType::TEXT
2191
1962
 
2192
1963
  result
2193
1964
  end
2194
1965
  .,.,
2195
1966
 
2196
- module_eval(<<'.,.,', 'parser.y', 1020)
1967
+ module_eval(<<'.,.,', 'parser.y', 787)
2197
1968
  def _reduce_118(val, _values, result)
2198
- if Rubyang::Xpath::Parser::DEBUG
2199
- puts '"NodeType" : "node"'
2200
- puts "val: #{val.inspect}"
2201
- end
1969
+ @@logger.debug { '"NodeType" : "node"' }
1970
+ @@logger.debug { "val: #{val.inspect}" }
2202
1971
  Rubyang::Xpath::NodeTest::NodeType::NODE
2203
1972
 
2204
1973
  result
2205
1974
  end
2206
1975
  .,.,
2207
1976
 
2208
- module_eval(<<'.,.,', 'parser.y', 1029)
1977
+ module_eval(<<'.,.,', 'parser.y', 794)
2209
1978
  def _reduce_119(val, _values, result)
2210
- if Rubyang::Xpath::Parser::DEBUG
2211
- puts '"QName" : "PrefixedName"'
2212
- puts "val: #{val.inspect}"
2213
- end
1979
+ @@logger.debug { '"QName" : "PrefixedName"' }
1980
+ @@logger.debug { "val: #{val.inspect}" }
2214
1981
  result = val[0]
2215
1982
 
2216
1983
  result
2217
1984
  end
2218
1985
  .,.,
2219
1986
 
2220
- module_eval(<<'.,.,', 'parser.y', 1037)
1987
+ module_eval(<<'.,.,', 'parser.y', 800)
2221
1988
  def _reduce_120(val, _values, result)
2222
- if Rubyang::Xpath::Parser::DEBUG
2223
- puts '"QName" : "UnprefixedName"'
2224
- puts "val: #{val.inspect}"
2225
- end
1989
+ @@logger.debug { '"QName" : "UnprefixedName"' }
1990
+ @@logger.debug { "val: #{val.inspect}" }
2226
1991
  result = val[0]
2227
1992
 
2228
1993
  result
2229
1994
  end
2230
1995
  .,.,
2231
1996
 
2232
- module_eval(<<'.,.,', 'parser.y', 1046)
1997
+ module_eval(<<'.,.,', 'parser.y', 807)
2233
1998
  def _reduce_121(val, _values, result)
2234
- if Rubyang::Xpath::Parser::DEBUG
2235
- puts '"PrefixedName" : "Prefix" ":" "LocalPart"'
2236
- puts "val: #{val.inspect}"
2237
- end
1999
+ @@logger.debug { '"PrefixedName" : "Prefix" ":" "LocalPart"' }
2000
+ @@logger.debug { "val: #{val.inspect}" }
2238
2001
  result = val[0] + val[1] + val[2]
2239
2002
 
2240
2003
  result
2241
2004
  end
2242
2005
  .,.,
2243
2006
 
2244
- module_eval(<<'.,.,', 'parser.y', 1055)
2007
+ module_eval(<<'.,.,', 'parser.y', 814)
2245
2008
  def _reduce_122(val, _values, result)
2246
- if Rubyang::Xpath::Parser::DEBUG
2247
- puts '"UnprefixedName" : "LocalPart"'
2248
- puts "val: #{val.inspect}"
2249
- end
2009
+ @@logger.debug { '"UnprefixedName" : "LocalPart"' }
2010
+ @@logger.debug { "val: #{val.inspect}" }
2250
2011
  result = val[0]
2251
2012
 
2252
2013
  result
2253
2014
  end
2254
2015
  .,.,
2255
2016
 
2256
- module_eval(<<'.,.,', 'parser.y', 1064)
2017
+ module_eval(<<'.,.,', 'parser.y', 821)
2257
2018
  def _reduce_123(val, _values, result)
2258
- if Rubyang::Xpath::Parser::DEBUG
2259
- puts '"Prefix" : "NCName"'
2260
- puts "val: #{val.inspect}"
2261
- end
2019
+ @@logger.debug { '"Prefix" : "NCName"' }
2020
+ @@logger.debug { "val: #{val.inspect}" }
2262
2021
  result = val[0]
2263
2022
 
2264
2023
  result
2265
2024
  end
2266
2025
  .,.,
2267
2026
 
2268
- module_eval(<<'.,.,', 'parser.y', 1073)
2027
+ module_eval(<<'.,.,', 'parser.y', 828)
2269
2028
  def _reduce_124(val, _values, result)
2270
- if Rubyang::Xpath::Parser::DEBUG
2271
- puts '"LocalPart" : "NCName"'
2272
- puts "val: #{val.inspect}"
2273
- end
2029
+ @@logger.debug { '"LocalPart" : "NCName"' }
2030
+ @@logger.debug { "val: #{val.inspect}" }
2274
2031
  result = val[0]
2275
2032
 
2276
2033
  result