rubyang 0.1.2.1 → 0.1.3

Sign up to get free protection for your applications and to get access to all the features.
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