myco 0.1.9 → 0.1.10

Sign up to get free protection for your applications and to get access to all the features.
Files changed (102) hide show
  1. checksums.yaml +4 -4
  2. data/lib/myco/bootstrap.my.rb +50 -14
  3. data/lib/myco/bootstrap/add_method.rb +5 -5
  4. data/lib/myco/bootstrap/meme.rb +2 -1
  5. data/lib/myco/code_tools/AST.my.rb +211 -43
  6. data/lib/myco/code_tools/AST/ArgumentAssembly.my.rb +92 -48
  7. data/lib/myco/code_tools/AST/ArrayAssembly.my.rb +39 -27
  8. data/lib/myco/code_tools/AST/Block.my.rb +176 -112
  9. data/lib/myco/code_tools/AST/BlockArgument.my.rb +29 -17
  10. data/lib/myco/code_tools/AST/BlockLiteral.my.rb +37 -17
  11. data/lib/myco/code_tools/AST/BlockParameter.my.rb +25 -9
  12. data/lib/myco/code_tools/AST/BranchOperator.my.rb +95 -75
  13. data/lib/myco/code_tools/AST/ConstantAccess.my.rb +52 -32
  14. data/lib/myco/code_tools/AST/ConstantAssignment.my.rb +52 -36
  15. data/lib/myco/code_tools/AST/ConstantDefine.my.rb +50 -26
  16. data/lib/myco/code_tools/AST/DeclareCategory.my.rb +38 -18
  17. data/lib/myco/code_tools/AST/DeclareExtension.my.rb +29 -13
  18. data/lib/myco/code_tools/AST/DeclareFile.my.rb +51 -31
  19. data/lib/myco/code_tools/AST/DeclareMeme.my.rb +96 -68
  20. data/lib/myco/code_tools/AST/DeclareObject.my.rb +66 -42
  21. data/lib/myco/code_tools/AST/DeclareString.my.rb +39 -19
  22. data/lib/myco/code_tools/AST/DeclaredScope.my.rb +92 -64
  23. data/lib/myco/code_tools/AST/Invoke.my +8 -4
  24. data/lib/myco/code_tools/AST/Invoke.my.rb +74 -31
  25. data/lib/myco/code_tools/AST/InvokeMethod.my.rb +34 -14
  26. data/lib/myco/code_tools/AST/KeywordAssembly.my.rb +36 -24
  27. data/lib/myco/code_tools/AST/KeywordOptionalParameter.my.rb +28 -8
  28. data/lib/myco/code_tools/AST/KeywordRequiredParameter.my.rb +23 -7
  29. data/lib/myco/code_tools/AST/KeywordRestParameter.my.rb +23 -7
  30. data/lib/myco/code_tools/AST/LocalVariableAccessAmbiguous.my.rb +24 -12
  31. data/lib/myco/code_tools/AST/LocalVariableAssignment.my.rb +30 -10
  32. data/lib/myco/code_tools/AST/Node.my.rb +234 -102
  33. data/lib/myco/code_tools/AST/NumericLiteral.my.rb +18 -6
  34. data/lib/myco/code_tools/AST/OptionalParameter.my.rb +33 -13
  35. data/lib/myco/code_tools/AST/ParameterAssembly.my.rb +275 -211
  36. data/lib/myco/code_tools/AST/PipeOperator.my.rb +42 -18
  37. data/lib/myco/code_tools/AST/Quest.my.rb +65 -37
  38. data/lib/myco/code_tools/AST/RequiredParameter.my.rb +20 -4
  39. data/lib/myco/code_tools/AST/RestParameter.my.rb +20 -4
  40. data/lib/myco/code_tools/AST/Script.my.rb +51 -23
  41. data/lib/myco/code_tools/AST/Sequence.my.rb +22 -10
  42. data/lib/myco/code_tools/AST/SplatValue.my.rb +28 -16
  43. data/lib/myco/code_tools/AST/StringCompose.my.rb +23 -11
  44. data/lib/myco/code_tools/AST/StringLiteral.my.rb +19 -7
  45. data/lib/myco/code_tools/AST/SymbolCompose.my.rb +27 -15
  46. data/lib/myco/code_tools/AST/SymbolLiteral.my.rb +18 -6
  47. data/lib/myco/code_tools/AST/ToRuby.my.rb +581 -341
  48. data/lib/myco/code_tools/AST/misc.my.rb +87 -35
  49. data/lib/myco/code_tools/Parser.my.rb +39 -12
  50. data/lib/myco/code_tools/parser/MycoBuilder.my.rb +106 -90
  51. data/lib/myco/code_tools/parser/MycoCharacterClasses.my.rb +98 -50
  52. data/lib/myco/code_tools/parser/MycoGrammar.my +1 -6
  53. data/lib/myco/code_tools/parser/MycoGrammar.my.rb +2124 -1710
  54. data/lib/myco/code_tools/parser/MycoTokens.my +0 -5
  55. data/lib/myco/code_tools/parser/MycoTokens.my.rb +387 -156
  56. data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces.my.rb +55 -11
  57. data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/BytecodeHelpers.my.rb +321 -205
  58. data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Capture.my.rb +223 -127
  59. data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Common.my.rb +188 -72
  60. data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Common/Parser.my +48 -0
  61. data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Common/Parser.my.rb +365 -189
  62. data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Composite.my.rb +313 -233
  63. data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Grammar.my.rb +99 -55
  64. data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Processor.my.rb +493 -325
  65. data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Stream.my.rb +138 -114
  66. data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Stream/Parser.my.rb +56 -44
  67. data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/String.my.rb +173 -93
  68. data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/String/Parser.my.rb +90 -70
  69. data/lib/myco/command.my.rb +85 -25
  70. data/lib/myco/command/inoculate.my.rb +219 -127
  71. data/lib/myco/core.my.rb +20 -4
  72. data/lib/myco/core/BasicDecorators.my.rb +211 -119
  73. data/lib/myco/core/BasicObject.my.rb +108 -44
  74. data/lib/myco/core/Category.my.rb +37 -13
  75. data/lib/myco/core/Decorator.my.rb +35 -27
  76. data/lib/myco/core/FileToplevel.my.rb +55 -27
  77. data/lib/myco/core/Loop.my.rb +16 -8
  78. data/lib/myco/core/Object.my.rb +34 -14
  79. data/lib/myco/core/Ruby.my.rb +13 -5
  80. data/lib/myco/core/Switch.my.rb +79 -47
  81. data/lib/myco/tools/BasicCommand.my.rb +79 -47
  82. data/lib/myco/tools/mycompile.my.rb +153 -69
  83. data/lib/myco/version.rb +1 -1
  84. metadata +34 -52
  85. data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Parser.my +0 -144
  86. data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Parser.my.rb +0 -221
  87. data/lib/myco/code_tools/parser/pegleromyces/spec/BasicSpec.my +0 -35
  88. data/lib/myco/code_tools/parser/pegleromyces/spec/BasicSpec.my.rb +0 -35
  89. data/lib/myco/code_tools/parser/pegleromyces/spec/Grammar.test.my +0 -10
  90. data/lib/myco/code_tools/parser/pegleromyces/spec/Grammar.test.my.rb +0 -9
  91. data/lib/myco/code_tools/parser/pegleromyces/spec/Patterns.test.my +0 -162
  92. data/lib/myco/code_tools/parser/pegleromyces/spec/Patterns.test.my.rb +0 -353
  93. data/lib/myco/code_tools/parser/pegleromyces/spec/Processor.test.my +0 -10
  94. data/lib/myco/code_tools/parser/pegleromyces/spec/Processor.test.my.rb +0 -9
  95. data/lib/myco/code_tools/parser/pegleromyces/spec/Stream/Parser.test.my +0 -49
  96. data/lib/myco/code_tools/parser/pegleromyces/spec/Stream/Parser.test.my.rb +0 -119
  97. data/lib/myco/code_tools/parser/pegleromyces/spec/Stream/Patterns.test.my +0 -131
  98. data/lib/myco/code_tools/parser/pegleromyces/spec/Stream/Patterns.test.my.rb +0 -595
  99. data/lib/myco/code_tools/parser/pegleromyces/spec/String/Parser.test.my +0 -120
  100. data/lib/myco/code_tools/parser/pegleromyces/spec/String/Parser.test.my.rb +0 -350
  101. data/lib/myco/code_tools/parser/pegleromyces/spec/run.my +0 -14
  102. data/lib/myco/code_tools/parser/pegleromyces/spec/run.my.rb +0 -12
data/lib/myco/code_tools/parser/MycoGrammar.my CHANGED
@@ -89,12 +89,7 @@ rule expr_atom_not_string:
89
89
  # Simple literals
90
90
 
91
91
  rule lit_simple:
92
- r(T.null[:t0]) { ast.null(t0) }
93
- / r(T.void[:t0]) { ast.void(t0) }
94
- / r(T.true[:t0]) { ast.true(t0) }
95
- / r(T.false[:t0]) { ast.false(t0) }
96
- / r(T.self[:t0]) { ast.self(t0) }
97
- / r(T.float[:t0]) { ast.numeric(t0, t0.float) }
92
+ r(T.float[:t0]) { ast.numeric(t0, t0.float) }
98
93
  / r(T.integer[:t0]) { ast.numeric(t0, t0.integer) }
99
94
  / r(T.symbol[:t0]) { ast.symbol(t0, t0.text.slice(Range.new(1,-1)).to_sym) } # TODO: more succinct here
100
95
 
data/lib/myco/code_tools/parser/MycoGrammar.my.rb CHANGED
@@ -1,1859 +1,2273 @@
1
1
 
2
2
  ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
3
3
  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
4
- declare_meme(:"MycoCharacterClasses.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
5
- declare_meme(:"MycoTokens.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
4
+ declare_meme(
5
+ :"MycoCharacterClasses.my",
6
+ [:import],
7
+ ::Object::Proc.new { |*| nil}
8
+ )
9
+ declare_meme(
10
+ :"MycoTokens.my",
11
+ [:import],
12
+ ::Object::Proc.new { |*| nil}
13
+ )
6
14
  ::Myco.cscope.for_method_definition::MycoGrammar = (::Myco::Component.new([::Myco.find_constant(:Pegleromyces)::Grammar], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
7
15
  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
8
16
  ::Myco.cscope.for_method_definition::C = (::Myco.find_constant(:MycoCharacterClasses))
9
17
  ::Myco.cscope.for_method_definition::T = (::Myco.find_constant(:MycoTokens))
10
18
  __category__(:rules).component_eval {(
11
- declare_meme(:root, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.declobj_expr_body.__send__(
12
- :[],
13
- :n0
14
- )) { || (self.ast.declfile(
15
- self.__send__(:n0),
16
- self.__send__(:n0)
17
- ))}.__send__(
18
- :[],
19
- :root
20
- ))}
21
- declare_meme(:decl, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.declobj.__send__(
22
- :/,
23
- self.declstr
24
- ).__send__(
25
- :/,
26
- self.copen
27
- ))}
28
- declare_meme(:declobj_expr, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.category.__send__(
29
- :/,
30
- self.declobj_expr_not_category
31
- ))}
32
- declare_meme(:declobj_expr_not_category, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.decl.__send__(
33
- :/,
34
- self.cdefn
35
- ).__send__(
36
- :/,
37
- self.meme
38
- ))}
39
- declare_meme(:meme_expr, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.arg_expr)}
40
- declare_meme(:arg_expr, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.assignment.__send__(
41
- :/,
42
- self.left_chained_operations
43
- ).__send__(
44
- :/,
45
- self.string_compose
46
- ).__send__(
47
- :/,
48
- self.symbol_compose
49
- ).__send__(
50
- :/,
51
- self.left_chained_piping
52
- ).__send__(
53
- :/,
54
- self.expr_atom
55
- ))}
56
- declare_meme(:expr_atom, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.decl.__send__(
57
- :/,
58
- self.left_chained_invocations
59
- ).__send__(
60
- :/,
61
- self.lit_string
62
- ).__send__(
63
- :/,
64
- self.lit_symstr
65
- ).__send__(
66
- :/,
67
- self.unary_operation
68
- ).__send__(
69
- :/,
70
- self.paren_expr
71
- ).__send__(
72
- :/,
73
- self.constant
74
- ).__send__(
75
- :/,
76
- self.lit_simple
77
- ).__send__(
78
- :/,
79
- self.lit_other
80
- ).__send__(
81
- :/,
82
- self.lit_array
83
- ).__send__(
84
- :/,
85
- self.invoke
86
- ))}
87
- declare_meme(:expr_atom_not_chained, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.decl.__send__(
88
- :/,
89
- self.lit_string
90
- ).__send__(
91
- :/,
92
- self.lit_symstr
93
- ).__send__(
94
- :/,
95
- self.unary_operation
96
- ).__send__(
97
- :/,
98
- self.paren_expr
99
- ).__send__(
100
- :/,
101
- self.constant
102
- ).__send__(
103
- :/,
104
- self.lit_simple
105
- ).__send__(
106
- :/,
107
- self.lit_other
108
- ).__send__(
109
- :/,
110
- self.lit_array
111
- ).__send__(
112
- :/,
113
- self.invoke
114
- ))}
115
- declare_meme(:expr_atom_not_string, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.decl.__send__(
116
- :/,
117
- self.left_chained_invocations
118
- ).__send__(
119
- :/,
120
- self.unary_operation
121
- ).__send__(
122
- :/,
123
- self.paren_expr
124
- ).__send__(
125
- :/,
126
- self.constant
127
- ).__send__(
128
- :/,
129
- self.lit_simple
130
- ).__send__(
131
- :/,
132
- self.lit_other
133
- ).__send__(
134
- :/,
135
- self.lit_array
136
- ).__send__(
137
- :/,
138
- self.invoke
139
- ))}
140
- declare_meme(:lit_simple, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).null.__send__(
141
- :[],
142
- :t0
143
- )) { || (self.ast.null(self.__send__(:t0)))}.__send__(
144
- :/,
145
- self.r(::Myco.find_constant(:T).void.__send__(
19
+ declare_meme(
20
+ :root,
21
+ [:rule],
22
+ ::Object::Proc.new { |*| (self.r(self.declobj_expr_body.__send__(
146
23
  :[],
147
- :t0
148
- )) { || (self.ast.void(self.__send__(:t0)))}
149
- ).__send__(
150
- :/,
151
- self.r(::Myco.find_constant(:T).true.__send__(
152
- :[],
153
- :t0
154
- )) { || (self.ast.true(self.__send__(:t0)))}
155
- ).__send__(
156
- :/,
157
- self.r(::Myco.find_constant(:T).false.__send__(
158
- :[],
159
- :t0
160
- )) { || (self.ast.false(self.__send__(:t0)))}
161
- ).__send__(
162
- :/,
163
- self.r(::Myco.find_constant(:T).self.__send__(
164
- :[],
165
- :t0
166
- )) { || (self.ast.self(self.__send__(:t0)))}
167
- ).__send__(
168
- :/,
169
- self.r(::Myco.find_constant(:T).float.__send__(
24
+ :n0
25
+ )) { |*| (self.ast.declfile(
26
+ self.__send__(:n0),
27
+ self.__send__(:n0)
28
+ ))}.__send__(
170
29
  :[],
171
- :t0
172
- )) { || (self.ast.numeric(
173
- self.__send__(:t0),
174
- self.__send__(:t0).float
30
+ :root
175
31
  ))}
176
- ).__send__(
177
- :/,
178
- self.r(::Myco.find_constant(:T).integer.__send__(
179
- :[],
180
- :t0
181
- )) { || (self.ast.numeric(
182
- self.__send__(:t0),
183
- self.__send__(:t0).integer
32
+ )
33
+ declare_meme(
34
+ :decl,
35
+ [:rule],
36
+ ::Object::Proc.new { |*| (self.declobj.__send__(
37
+ :/,
38
+ self.declstr
39
+ ).__send__(
40
+ :/,
41
+ self.copen
42
+ ))}
43
+ )
44
+ declare_meme(
45
+ :declobj_expr,
46
+ [:rule],
47
+ ::Object::Proc.new { |*| (self.category.__send__(
48
+ :/,
49
+ self.declobj_expr_not_category
50
+ ))}
51
+ )
52
+ declare_meme(
53
+ :declobj_expr_not_category,
54
+ [:rule],
55
+ ::Object::Proc.new { |*| (self.decl.__send__(
56
+ :/,
57
+ self.cdefn
58
+ ).__send__(
59
+ :/,
60
+ self.meme
61
+ ))}
62
+ )
63
+ declare_meme(
64
+ :meme_expr,
65
+ [:rule],
66
+ ::Object::Proc.new { |*| (self.arg_expr)}
67
+ )
68
+ declare_meme(
69
+ :arg_expr,
70
+ [:rule],
71
+ ::Object::Proc.new { |*| (self.assignment.__send__(
72
+ :/,
73
+ self.left_chained_operations
74
+ ).__send__(
75
+ :/,
76
+ self.string_compose
77
+ ).__send__(
78
+ :/,
79
+ self.symbol_compose
80
+ ).__send__(
81
+ :/,
82
+ self.left_chained_piping
83
+ ).__send__(
84
+ :/,
85
+ self.expr_atom
86
+ ))}
87
+ )
88
+ declare_meme(
89
+ :expr_atom,
90
+ [:rule],
91
+ ::Object::Proc.new { |*| (self.decl.__send__(
92
+ :/,
93
+ self.left_chained_invocations
94
+ ).__send__(
95
+ :/,
96
+ self.lit_string
97
+ ).__send__(
98
+ :/,
99
+ self.lit_symstr
100
+ ).__send__(
101
+ :/,
102
+ self.unary_operation
103
+ ).__send__(
104
+ :/,
105
+ self.paren_expr
106
+ ).__send__(
107
+ :/,
108
+ self.constant
109
+ ).__send__(
110
+ :/,
111
+ self.lit_simple
112
+ ).__send__(
113
+ :/,
114
+ self.lit_other
115
+ ).__send__(
116
+ :/,
117
+ self.lit_array
118
+ ).__send__(
119
+ :/,
120
+ self.invoke
121
+ ))}
122
+ )
123
+ declare_meme(
124
+ :expr_atom_not_chained,
125
+ [:rule],
126
+ ::Object::Proc.new { |*| (self.decl.__send__(
127
+ :/,
128
+ self.lit_string
129
+ ).__send__(
130
+ :/,
131
+ self.lit_symstr
132
+ ).__send__(
133
+ :/,
134
+ self.unary_operation
135
+ ).__send__(
136
+ :/,
137
+ self.paren_expr
138
+ ).__send__(
139
+ :/,
140
+ self.constant
141
+ ).__send__(
142
+ :/,
143
+ self.lit_simple
144
+ ).__send__(
145
+ :/,
146
+ self.lit_other
147
+ ).__send__(
148
+ :/,
149
+ self.lit_array
150
+ ).__send__(
151
+ :/,
152
+ self.invoke
153
+ ))}
154
+ )
155
+ declare_meme(
156
+ :expr_atom_not_string,
157
+ [:rule],
158
+ ::Object::Proc.new { |*| (self.decl.__send__(
159
+ :/,
160
+ self.left_chained_invocations
161
+ ).__send__(
162
+ :/,
163
+ self.unary_operation
164
+ ).__send__(
165
+ :/,
166
+ self.paren_expr
167
+ ).__send__(
168
+ :/,
169
+ self.constant
170
+ ).__send__(
171
+ :/,
172
+ self.lit_simple
173
+ ).__send__(
174
+ :/,
175
+ self.lit_other
176
+ ).__send__(
177
+ :/,
178
+ self.lit_array
179
+ ).__send__(
180
+ :/,
181
+ self.invoke
184
182
  ))}
185
- ).__send__(
186
- :/,
187
- self.r(::Myco.find_constant(:T).symbol.__send__(
183
+ )
184
+ declare_meme(
185
+ :lit_simple,
186
+ [:rule],
187
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).float.__send__(
188
188
  :[],
189
189
  :t0
190
- )) { || (self.ast.symbol(
190
+ )) { |*| (self.ast.numeric(
191
191
  self.__send__(:t0),
192
- self.__send__(:t0).text.slice(::Myco.find_constant(:Range).new(
193
- 1,
194
- -1
195
- )).to_sym
192
+ self.__send__(:t0).float
193
+ ))}.__send__(
194
+ :/,
195
+ self.r(::Myco.find_constant(:T).integer.__send__(
196
+ :[],
197
+ :t0
198
+ )) { |*| (self.ast.numeric(
199
+ self.__send__(:t0),
200
+ self.__send__(:t0).integer
201
+ ))}
202
+ ).__send__(
203
+ :/,
204
+ self.r(::Myco.find_constant(:T).symbol.__send__(
205
+ :[],
206
+ :t0
207
+ )) { |*| (self.ast.symbol(
208
+ self.__send__(:t0),
209
+ self.__send__(:t0).text.slice(::Myco.find_constant(:Range).new(
210
+ 1,
211
+ -1
212
+ )).to_sym
213
+ ))}
196
214
  ))}
197
- ))}
198
- declare_meme(:lit_other, [], nil, ::Myco.cscope.dup) { |*| (self.lit_block)}
199
- declare_meme(:lit_block, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).op_toproc.__send__(
200
- :[],
201
- :to
202
- ).__send__(
203
- :+,
204
- self.block_body.__send__(
205
- :[],
206
- :n1
207
- )
208
- )) { || (self.ast.blklit(
209
- self.to,
210
- self.__send__(:n1)
211
- ))})}
212
- declare_meme(:block_body, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:C).spc_nl.__send__(:*).__send__(
213
- :+,
214
- self.param_list.__send__(:-).__send__(
215
- :[],
216
- :np
217
- )
218
- ).__send__(
219
- :+,
220
- ::Myco.find_constant(:C).spc_nl.__send__(:*)
221
- ).__send__(
222
- :+,
223
- self.meme_enclosed_expr_body.__send__(
215
+ )
216
+ declare_meme(
217
+ :lit_other,
218
+ [],
219
+ ::Object::Proc.new { |*| (self.lit_block)}
220
+ )
221
+ declare_meme(
222
+ :lit_block,
223
+ [:rule],
224
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).op_toproc.__send__(
224
225
  :[],
225
- :nb
226
- )
227
- )) { || (self.ast.block(
228
- self.nb,
229
- self.np,
230
- self.nb
231
- ))})}
232
- declare_meme(:open_block_body, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:C).spc_nl.__send__(:*).__send__(
233
- :+,
234
- self.param_list.__send__(:-).__send__(
235
- :[],
236
- :np
237
- )
238
- ).__send__(
239
- :+,
240
- ::Myco.find_constant(:C).spc_nl.__send__(:*)
241
- ).__send__(
242
- :+,
243
- self.meme_inline_expr_body.__send__(
244
- :[],
245
- :nb
246
- )
247
- )) { || (self.ast.block(
248
- self.nb,
249
- self.np,
250
- self.nb
251
- ))})}
252
- declare_meme(:lit_string, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).string_begin.__send__(
253
- :+,
254
- ::Myco.find_constant(:T).string_body.__send__(
255
- :[],
256
- :tb
257
- )
258
- ).__send__(
259
- :+,
260
- ::Myco.find_constant(:T).string_end
261
- ).__send__(
262
- :/,
263
- ::Myco.find_constant(:T).sstring_begin.__send__(
226
+ :to
227
+ ).__send__(
228
+ :+,
229
+ self.block_body.__send__(
230
+ :[],
231
+ :n1
232
+ )
233
+ )) { |*| (self.ast.blklit(
234
+ self.to,
235
+ self.__send__(:n1)
236
+ ))})}
237
+ )
238
+ declare_meme(
239
+ :block_body,
240
+ [:rule],
241
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:C).spc_nl.__send__(:*).__send__(
242
+ :+,
243
+ self.param_list.__send__(:-).__send__(
244
+ :[],
245
+ :np
246
+ )
247
+ ).__send__(
264
248
  :+,
265
- ::Myco.find_constant(:T).sstring_body.__send__(
249
+ ::Myco.find_constant(:C).spc_nl.__send__(:*)
250
+ ).__send__(
251
+ :+,
252
+ self.meme_enclosed_expr_body.__send__(
253
+ :[],
254
+ :nb
255
+ )
256
+ )) { |*| (self.ast.block(
257
+ self.nb,
258
+ self.np,
259
+ self.nb
260
+ ))})}
261
+ )
262
+ declare_meme(
263
+ :open_block_body,
264
+ [:rule],
265
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:C).spc_nl.__send__(:*).__send__(
266
+ :+,
267
+ self.param_list.__send__(:-).__send__(
268
+ :[],
269
+ :np
270
+ )
271
+ ).__send__(
272
+ :+,
273
+ ::Myco.find_constant(:C).spc_nl.__send__(:*)
274
+ ).__send__(
275
+ :+,
276
+ self.meme_inline_expr_body.__send__(
277
+ :[],
278
+ :nb
279
+ )
280
+ )) { |*| (self.ast.block(
281
+ self.nb,
282
+ self.np,
283
+ self.nb
284
+ ))})}
285
+ )
286
+ declare_meme(
287
+ :lit_string,
288
+ [:rule],
289
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).string_begin.__send__(
290
+ :+,
291
+ ::Myco.find_constant(:T).string_body.__send__(
266
292
  :[],
267
293
  :tb
268
294
  )
269
295
  ).__send__(
270
296
  :+,
271
- ::Myco.find_constant(:T).sstring_end
272
- )
273
- )) { || (self.ast.symbol(
274
- self.tb,
275
- self.encode_escapes(self.tb.text)
276
- ))})}
277
- declare_meme(:lit_string_as_symbol, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).string_begin.__send__(
278
- :+,
279
- ::Myco.find_constant(:T).string_body.__send__(
280
- :[],
281
- :tb
282
- )
283
- ).__send__(
284
- :+,
285
- ::Myco.find_constant(:T).string_end
286
- ).__send__(
287
- :/,
288
- ::Myco.find_constant(:T).sstring_begin.__send__(
297
+ ::Myco.find_constant(:T).string_end
298
+ ).__send__(
299
+ :/,
300
+ ::Myco.find_constant(:T).sstring_begin.__send__(
301
+ :+,
302
+ ::Myco.find_constant(:T).sstring_body.__send__(
303
+ :[],
304
+ :tb
305
+ )
306
+ ).__send__(
307
+ :+,
308
+ ::Myco.find_constant(:T).sstring_end
309
+ )
310
+ )) { |*| (self.ast.symbol(
311
+ self.tb,
312
+ self.encode_escapes(self.tb.text)
313
+ ))})}
314
+ )
315
+ declare_meme(
316
+ :lit_string_as_symbol,
317
+ [:rule],
318
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).string_begin.__send__(
289
319
  :+,
290
- ::Myco.find_constant(:T).sstring_body.__send__(
320
+ ::Myco.find_constant(:T).string_body.__send__(
291
321
  :[],
292
322
  :tb
293
323
  )
294
324
  ).__send__(
295
325
  :+,
296
- ::Myco.find_constant(:T).sstring_end
297
- )
298
- )) { || (self.ast.symbol(
299
- self.tb,
300
- self.encode_escapes(self.tb.text).to_sym
301
- ))})}
302
- declare_meme(:lit_symstr, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).symstr_begin.__send__(
303
- :+,
304
- ::Myco.find_constant(:T).string_body.__send__(
305
- :[],
306
- :tb
307
- )
308
- ).__send__(
309
- :+,
310
- ::Myco.find_constant(:T).string_end
311
- )) { || (self.ast.symbol(
312
- self.tb,
313
- self.encode_escapes(self.tb.text).to_sym
314
- ))})}
315
- declare_meme(:category_name, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).catgry_begin.__send__(
316
- :+,
317
- ::Myco.find_constant(:T).catgry_body.__send__(
326
+ ::Myco.find_constant(:T).string_end
327
+ ).__send__(
328
+ :/,
329
+ ::Myco.find_constant(:T).sstring_begin.__send__(
330
+ :+,
331
+ ::Myco.find_constant(:T).sstring_body.__send__(
332
+ :[],
333
+ :tb
334
+ )
335
+ ).__send__(
336
+ :+,
337
+ ::Myco.find_constant(:T).sstring_end
338
+ )
339
+ )) { |*| (self.ast.symbol(
340
+ self.tb,
341
+ self.encode_escapes(self.tb.text).to_sym
342
+ ))})}
343
+ )
344
+ declare_meme(
345
+ :lit_symstr,
346
+ [:rule],
347
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).symstr_begin.__send__(
348
+ :+,
349
+ ::Myco.find_constant(:T).string_body.__send__(
350
+ :[],
351
+ :tb
352
+ )
353
+ ).__send__(
354
+ :+,
355
+ ::Myco.find_constant(:T).string_end
356
+ )) { |*| (self.ast.symbol(
357
+ self.tb,
358
+ self.encode_escapes(self.tb.text).to_sym
359
+ ))})}
360
+ )
361
+ declare_meme(
362
+ :category_name,
363
+ [:rule],
364
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).catgry_begin.__send__(
365
+ :+,
366
+ ::Myco.find_constant(:T).catgry_body.__send__(
367
+ :[],
368
+ :tb
369
+ )
370
+ ).__send__(
371
+ :+,
372
+ ::Myco.find_constant(:T).catgry_end
373
+ )) { |*| (self.ast.symbol(
374
+ self.tb,
375
+ self.encode_escapes(self.tb.text).to_sym
376
+ ))})}
377
+ )
378
+ declare_meme(
379
+ :string_compose_part,
380
+ [:rule],
381
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:C).spc.__send__(:*).__send__(
382
+ :+,
383
+ self.expr_atom_not_string.__send__(
384
+ :[],
385
+ :n0
386
+ )
387
+ ).__send__(
388
+ :+,
389
+ ::Myco.find_constant(:C).spc.__send__(:*)
390
+ ).__send__(
391
+ :+,
392
+ self.lit_string.__send__(
393
+ :[],
394
+ :n1
395
+ )
396
+ )) { |*| ([
397
+ self.__send__(:n0),
398
+ self.__send__(:n1)
399
+ ])})}
400
+ )
401
+ declare_meme(
402
+ :string_compose_parts,
403
+ [:rule],
404
+ ::Object::Proc.new { |*| (self.r(self.string_compose_part.__send__(:+).__send__(
318
405
  :[],
319
- :tb
320
- )
321
- ).__send__(
322
- :+,
323
- ::Myco.find_constant(:T).catgry_end
324
- )) { || (self.ast.symbol(
325
- self.tb,
326
- self.encode_escapes(self.tb.text).to_sym
327
- ))})}
328
- declare_meme(:string_compose_part, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:C).spc.__send__(:*).__send__(
329
- :+,
330
- self.expr_atom_not_string.__send__(
406
+ :nlist
407
+ )) { |*| (self.nlist.flatten)})}
408
+ )
409
+ declare_meme(
410
+ :string_compose,
411
+ [:rule],
412
+ ::Object::Proc.new { |*| (self.r(self.lit_string.__send__(
331
413
  :[],
332
414
  :n0
333
- )
334
- ).__send__(
335
- :+,
336
- ::Myco.find_constant(:C).spc.__send__(:*)
337
- ).__send__(
338
- :+,
339
- self.lit_string.__send__(
340
- :[],
341
- :n1
342
- )
343
- )) { || ([
344
- self.__send__(:n0),
345
- self.__send__(:n1)
346
- ])})}
347
- declare_meme(:string_compose_parts, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.string_compose_part.__send__(:+).__send__(
348
- :[],
349
- :nlist
350
- )) { || (self.nlist.flatten)})}
351
- declare_meme(:string_compose, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.lit_string.__send__(
352
- :[],
353
- :n0
354
- ).__send__(
355
- :+,
356
- self.string_compose_parts.__send__(
357
- :[],
358
- :nrest
359
- )
360
- )) { || (self.ast.string_compose(
361
- self.__send__(:n0),
362
- [self.__send__(:n0)].__send__(
363
- :+,
364
- self.nrest
365
- )
366
- ))})}
367
- declare_meme(:symbol_compose, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.lit_symstr.__send__(
368
- :[],
369
- :n0
370
- ).__send__(
371
- :+,
372
- self.string_compose_parts.__send__(
415
+ ).__send__(
416
+ :+,
417
+ self.string_compose_parts.__send__(
418
+ :[],
419
+ :nrest
420
+ )
421
+ )) { |*| (self.ast.string_compose(
422
+ self.__send__(:n0),
423
+ [self.__send__(:n0)].__send__(
424
+ :+,
425
+ self.nrest
426
+ )
427
+ ))})}
428
+ )
429
+ declare_meme(
430
+ :symbol_compose,
431
+ [:rule],
432
+ ::Object::Proc.new { |*| (self.r(self.lit_symstr.__send__(
373
433
  :[],
374
- :nrest
375
- )
376
- )) { || (self.ast.symbol_compose(
377
- self.__send__(:n0),
378
- [self.__send__(:n0)].__send__(
379
- :+,
380
- self.nrest
381
- )
382
- ))})}
383
- declare_meme(:colon_const, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).scope.__send__(
384
- :+,
385
- ::Myco.find_constant(:T).constant.__send__(
434
+ :n0
435
+ ).__send__(
436
+ :+,
437
+ self.string_compose_parts.__send__(
438
+ :[],
439
+ :nrest
440
+ )
441
+ )) { |*| (self.ast.symbol_compose(
442
+ self.__send__(:n0),
443
+ [self.__send__(:n0)].__send__(
444
+ :+,
445
+ self.nrest
446
+ )
447
+ ))})}
448
+ )
449
+ declare_meme(
450
+ :colon_const,
451
+ [:rule],
452
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).scope.__send__(
453
+ :+,
454
+ ::Myco.find_constant(:T).constant.__send__(
455
+ :[],
456
+ :tc
457
+ )
458
+ )) { |*| (self.tc)})}
459
+ )
460
+ declare_meme(
461
+ :constant,
462
+ [:rule],
463
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).scope.__send__(:-).__send__(
386
464
  :[],
387
- :tc
388
- )
389
- )) { || (self.tc)})}
390
- declare_meme(:constant, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).scope.__send__(:-).__send__(
391
- :[],
392
- :ts
393
- ).__send__(
394
- :+,
395
- ::Myco.find_constant(:T).constant.__send__(
465
+ :ts
466
+ ).__send__(
467
+ :+,
468
+ ::Myco.find_constant(:T).constant.__send__(
469
+ :[],
470
+ :tc
471
+ )
472
+ ).__send__(
473
+ :+,
474
+ self.colon_const.__send__(:*).__send__(
475
+ :[],
476
+ :trest
477
+ )
478
+ )) { |*| (self.ast.const(
479
+ ::Myco.branch_op(:"||", self.ts) {self.tc},
480
+ self.ts.__send__(:!).__send__(:!),
481
+ [
482
+ self.tc.sym,
483
+ *self.trest.map(&:sym)
484
+ ]
485
+ ))})}
486
+ )
487
+ declare_meme(
488
+ :const_sep,
489
+ [:rule],
490
+ ::Object::Proc.new { |*| (::Myco.find_constant(:C).spc_nl.__send__(:*).__send__(
491
+ :+,
492
+ ::Myco.find_constant(:T).const_sep
493
+ ).__send__(
494
+ :+,
495
+ ::Myco.find_constant(:C).spc_nl.__send__(:*)
496
+ ).__send__(:+))}
497
+ )
498
+ declare_meme(
499
+ :sepd_constant,
500
+ [:rule],
501
+ ::Object::Proc.new { |*| (self.r(self.const_sep.__send__(
502
+ :+,
503
+ self.constant.__send__(
504
+ :[],
505
+ :n0
506
+ )
507
+ )) { |*| (self.__send__(:n0))})}
508
+ )
509
+ declare_meme(
510
+ :constant_list,
511
+ [:rule],
512
+ ::Object::Proc.new { |*| (self.r(self.constant.__send__(
396
513
  :[],
397
- :tc
398
- )
399
- ).__send__(
400
- :+,
401
- self.colon_const.__send__(:*).__send__(
514
+ :n0
515
+ ).__send__(
516
+ :+,
517
+ self.sepd_constant.__send__(:*).__send__(
518
+ :[],
519
+ :nrest
520
+ )
521
+ )) { |*| (self.ast.array(
522
+ self.__send__(:n0),
523
+ [
524
+ self.__send__(:n0),
525
+ *self.nrest
526
+ ]
527
+ ))})}
528
+ )
529
+ declare_meme(
530
+ :id_as_symbol,
531
+ [:rule],
532
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).identifier.__send__(
402
533
  :[],
403
- :trest
404
- )
405
- )) { || (self.ast.const(
406
- ::Myco.branch_op(:"||", self.ts) {self.tc},
407
- self.ts.__send__(:!).__send__(:!),
408
- [
409
- self.tc.sym,
410
- *self.trest.map(&:sym)
411
- ]
412
- ))})}
413
- declare_meme(:const_sep, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:C).spc_nl.__send__(:*).__send__(
414
- :+,
415
- ::Myco.find_constant(:T).const_sep
416
- ).__send__(
417
- :+,
418
- ::Myco.find_constant(:C).spc_nl.__send__(:*)
419
- ).__send__(:+))}
420
- declare_meme(:sepd_constant, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.const_sep.__send__(
421
- :+,
422
- self.constant.__send__(
534
+ :t0
535
+ )) { |*| (self.ast.symbol(
536
+ self.__send__(:t0),
537
+ self.__send__(:t0).sym
538
+ ))})}
539
+ )
540
+ declare_meme(
541
+ :declobj_sepd_expr,
542
+ [:rule],
543
+ ::Object::Proc.new { |*| (self.r(self.arg_sep.__send__(
544
+ :+,
545
+ self.declobj_expr.__send__(
546
+ :[],
547
+ :n0
548
+ )
549
+ )) { |*| (self.__send__(:n0))})}
550
+ )
551
+ declare_meme(
552
+ :declobj_sepd_exprs,
553
+ [:rule],
554
+ ::Object::Proc.new { |*| (self.r(self.declobj_expr.__send__(
423
555
  :[],
424
556
  :n0
425
- )
426
- )) { || (self.__send__(:n0))})}
427
- declare_meme(:constant_list, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.constant.__send__(
428
- :[],
429
- :n0
430
- ).__send__(
431
- :+,
432
- self.sepd_constant.__send__(:*).__send__(
433
- :[],
434
- :nrest
435
- )
436
- )) { || (self.ast.array(
437
- self.__send__(:n0),
438
- [
557
+ ).__send__(
558
+ :+,
559
+ self.declobj_sepd_expr.__send__(:*).__send__(
560
+ :[],
561
+ :nrest
562
+ )
563
+ ).__send__(
564
+ :+,
565
+ self.arg_sep_opt
566
+ )) { |*| ([
439
567
  self.__send__(:n0),
440
568
  *self.nrest
441
- ]
442
- ))})}
443
- declare_meme(:id_as_symbol, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).identifier.__send__(
444
- :[],
445
- :t0
446
- )) { || (self.ast.symbol(
447
- self.__send__(:t0),
448
- self.__send__(:t0).sym
449
- ))})}
450
- declare_meme(:declobj_sepd_expr, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.arg_sep.__send__(
451
- :+,
452
- self.declobj_expr.__send__(
453
- :[],
454
- :n0
455
- )
456
- )) { || (self.__send__(:n0))})}
457
- declare_meme(:declobj_sepd_exprs, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.declobj_expr.__send__(
458
- :[],
459
- :n0
460
- ).__send__(
461
- :+,
462
- self.declobj_sepd_expr.__send__(:*).__send__(
463
- :[],
464
- :nrest
465
- )
466
- ).__send__(
467
- :+,
468
- self.arg_sep_opt
469
- )) { || ([
470
- self.__send__(:n0),
471
- *self.nrest
472
- ])})}
473
- declare_meme(:declobj_expr_body, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.arg_sep_opt.__send__(
474
- :+,
475
- self.declobj_sepd_exprs.__send__(
476
- :[],
477
- :nlist
478
- )
479
- ).__send__(
480
- :+,
481
- ::Myco.find_constant(:T).declare_end.__send__(
482
- :[],
483
- :te
484
- )
485
- )) { || (self.ast.sequence(
486
- self.nlist.first,
487
- self.nlist
488
- ))}.__send__(
489
- :/,
490
- self.r(self.arg_sep_opt.__send__(
569
+ ])})}
570
+ )
571
+ declare_meme(
572
+ :declobj_expr_body,
573
+ [:rule],
574
+ ::Object::Proc.new { |*| (self.r(self.arg_sep_opt.__send__(
575
+ :+,
576
+ self.declobj_sepd_exprs.__send__(
577
+ :[],
578
+ :nlist
579
+ )
580
+ ).__send__(
491
581
  :+,
492
582
  ::Myco.find_constant(:T).declare_end.__send__(
493
583
  :[],
494
584
  :te
495
585
  )
496
- )) { || (self.ast.null(self.te))}
497
- ))}
498
- declare_meme(:declobj, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.constant_list.__send__(
499
- :[],
500
- :n0
501
- ).__send__(
502
- :+,
503
- ::Myco.find_constant(:C).spc_nl.__send__(:*)
504
- ).__send__(
505
- :+,
506
- ::Myco.find_constant(:T).declare_begin.__send__(
507
- :[],
508
- :tb
509
- )
510
- ).__send__(
511
- :+,
512
- self.declobj_expr_body.__send__(
513
- :[],
514
- :n1
515
- )
516
- )) { || (self.ast.declobj(
517
- self.tb,
518
- self.__send__(:n0),
519
- self.__send__(:n1)
520
- ))})}
521
- declare_meme(:category_expr, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.declobj_expr_not_category)}
522
- declare_meme(:category_sepd_expr, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.arg_sep.__send__(
523
- :+,
524
- self.category_expr.__send__(
525
- :[],
526
- :n0
527
- )
528
- )) { || (self.__send__(:n0))})}
529
- declare_meme(:category_sepd_exprs, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.arg_sep.__send__(
530
- :+,
531
- self.category_expr.__send__(
586
+ )) { |*| (self.ast.sequence(
587
+ self.nlist.first,
588
+ self.nlist
589
+ ))}.__send__(
590
+ :/,
591
+ self.r(self.arg_sep_opt.__send__(
592
+ :+,
593
+ ::Myco.find_constant(:T).declare_end.__send__(
594
+ :[],
595
+ :te
596
+ )
597
+ )) { |*| (self.ast.null(self.te))}
598
+ ))}
599
+ )
600
+ declare_meme(
601
+ :declobj,
602
+ [:rule],
603
+ ::Object::Proc.new { |*| (self.r(self.constant_list.__send__(
532
604
  :[],
533
605
  :n0
534
- )
535
- ).__send__(
536
- :+,
537
- self.category_sepd_expr.__send__(:*).__send__(
538
- :[],
539
- :nrest
540
- )
541
- )) { || ([
542
- self.__send__(:n0),
543
- *self.nrest
544
- ])})}
545
- declare_meme(:category, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.category_name.__send__(
546
- :[],
547
- :n0
548
- ).__send__(
549
- :+,
550
- self.category_sepd_exprs.__send__(:-).__send__(
551
- :[],
552
- :nlist
553
- )
554
- ).__send__(
555
- :+,
556
- self.arg_sep_opt.__send__(
606
+ ).__send__(
557
607
  :+,
558
- ::Myco.find_constant(:T).catgry_begin.__send__(
559
- :/,
560
- ::Myco.find_constant(:T).declare_end
608
+ ::Myco.find_constant(:C).spc_nl.__send__(:*)
609
+ ).__send__(
610
+ :+,
611
+ ::Myco.find_constant(:T).declare_begin.__send__(
612
+ :[],
613
+ :tb
561
614
  )
562
- ).__send__(:!).__send__(:!)
563
- )) { || (self.ast.category(
564
- self.__send__(:n0),
565
- self.__send__(:n0).value,
566
- ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.nlist) {self.ast.sequence(
567
- self.nlist.first,
568
- self.nlist
569
- )}) {self.ast.null(self.__send__(:n0))}
570
- ))})}
571
- declare_meme(:copen, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.constant.__send__(
572
- :[],
573
- :n0
574
- ).__send__(
575
- :+,
576
- ::Myco.find_constant(:C).spc_nl.__send__(:*)
577
- ).__send__(
578
- :+,
579
- ::Myco.find_constant(:T).reopen.__send__(
580
- :[],
581
- :tb
582
- )
583
- ).__send__(
584
- :+,
585
- ::Myco.find_constant(:C).spc_nl.__send__(:*)
586
- ).__send__(
587
- :+,
588
- ::Myco.find_constant(:T).declare_begin
589
- ).__send__(
590
- :+,
591
- self.declobj_expr_body.__send__(
592
- :[],
593
- :n1
594
- )
595
- )) { || (self.ast.copen(
596
- self.tb,
597
- self.__send__(:n0),
598
- self.__send__(:n1)
599
- ))})}
600
- declare_meme(:cdefn, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.constant.__send__(
601
- :[],
602
- :n0
603
- ).__send__(
604
- :+,
605
- ::Myco.find_constant(:C).spc_nl.__send__(:*)
606
- ).__send__(
607
- :+,
608
- ::Myco.find_constant(:T).define.__send__(
609
- :[],
610
- :tb
611
- )
612
- ).__send__(
613
- :+,
614
- ::Myco.find_constant(:C).spc_nl.__send__(:*)
615
- ).__send__(
616
- :+,
617
- self.declobj.__send__(
618
- :[],
619
- :n1
620
- )
621
- )) { || (self.ast.cdefn(
622
- self.tb,
623
- self.__send__(:n0),
624
- self.__send__(:n1)
625
- ))})}
626
- declare_meme(:declstr_body, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).declstr_begin.__send__(
627
- :[],
628
- :tb
629
- ).__send__(
630
- :+,
631
- ::Myco.find_constant(:C).spc.__send__(:*)
632
- ).__send__(
633
- :+,
634
- ::Myco.find_constant(:C).nl
635
- ).__send__(
636
- :+,
637
- ::Myco.find_constant(:T).declstr_body.__send__(
638
- :[],
639
- :ts
640
- )
641
- ).__send__(
642
- :+,
643
- ::Myco.find_constant(:C).spc_nl.__send__(:*)
644
- ).__send__(
645
- :+,
646
- ::Myco.find_constant(:T).declstr_end
647
- )) { || (self.ast.str(
648
- self.tb,
649
- self.ts.text
650
- ))})}
651
- declare_meme(:declstr, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.constant_list.__send__(
652
- :[],
653
- :nc
654
- ).__send__(
655
- :+,
656
- ::Myco.find_constant(:C).spc.__send__(:+)
657
- ).__send__(
658
- :+,
659
- self.declstr_body.__send__(
615
+ ).__send__(
616
+ :+,
617
+ self.declobj_expr_body.__send__(
618
+ :[],
619
+ :n1
620
+ )
621
+ )) { |*| (self.ast.declobj(
622
+ self.tb,
623
+ self.__send__(:n0),
624
+ self.__send__(:n1)
625
+ ))})}
626
+ )
627
+ declare_meme(
628
+ :category_expr,
629
+ [:rule],
630
+ ::Object::Proc.new { |*| (self.declobj_expr_not_category)}
631
+ )
632
+ declare_meme(
633
+ :category_sepd_expr,
634
+ [:rule],
635
+ ::Object::Proc.new { |*| (self.r(self.arg_sep.__send__(
636
+ :+,
637
+ self.category_expr.__send__(
638
+ :[],
639
+ :n0
640
+ )
641
+ )) { |*| (self.__send__(:n0))})}
642
+ )
643
+ declare_meme(
644
+ :category_sepd_exprs,
645
+ [:rule],
646
+ ::Object::Proc.new { |*| (self.r(self.arg_sep.__send__(
647
+ :+,
648
+ self.category_expr.__send__(
649
+ :[],
650
+ :n0
651
+ )
652
+ ).__send__(
653
+ :+,
654
+ self.category_sepd_expr.__send__(:*).__send__(
655
+ :[],
656
+ :nrest
657
+ )
658
+ )) { |*| ([
659
+ self.__send__(:n0),
660
+ *self.nrest
661
+ ])})}
662
+ )
663
+ declare_meme(
664
+ :category,
665
+ [:rule],
666
+ ::Object::Proc.new { |*| (self.r(self.category_name.__send__(
660
667
  :[],
661
- :nb
662
- )
663
- )) { || (self.ast.declstr(
664
- self.nc,
665
- self.nc,
666
- self.nb
667
- ))})}
668
- declare_meme(:assignment, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.local_assignment.__send__(
669
- :/,
670
- self.invoke_assignment
671
- ))}
672
- declare_meme(:assign_rhs, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.arg_expr)}
673
- declare_meme(:local_assignment, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).identifier.__send__(
674
- :[],
675
- :ti
676
- ).__send__(
677
- :+,
678
- ::Myco.find_constant(:C).spc_nl.__send__(:*)
679
- ).__send__(
680
- :+,
681
- ::Myco.find_constant(:T).assign.__send__(
668
+ :n0
669
+ ).__send__(
670
+ :+,
671
+ self.category_sepd_exprs.__send__(:-).__send__(
672
+ :[],
673
+ :nlist
674
+ )
675
+ ).__send__(
676
+ :+,
677
+ self.arg_sep_opt.__send__(
678
+ :+,
679
+ ::Myco.find_constant(:T).catgry_begin.__send__(
680
+ :/,
681
+ ::Myco.find_constant(:T).declare_end
682
+ )
683
+ ).__send__(:!).__send__(:!)
684
+ )) { |*| (self.ast.category(
685
+ self.__send__(:n0),
686
+ self.__send__(:n0).value,
687
+ ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.nlist) {self.ast.sequence(
688
+ self.nlist.first,
689
+ self.nlist
690
+ )}) {self.ast.null(self.__send__(:n0))}
691
+ ))})}
692
+ )
693
+ declare_meme(
694
+ :copen,
695
+ [:rule],
696
+ ::Object::Proc.new { |*| (self.r(self.constant.__send__(
682
697
  :[],
683
- :to
684
- )
685
- ).__send__(
686
- :+,
687
- ::Myco.find_constant(:C).spc_nl.__send__(:*)
688
- ).__send__(
689
- :+,
690
- self.assign_rhs.__send__(
698
+ :n0
699
+ ).__send__(
700
+ :+,
701
+ ::Myco.find_constant(:C).spc_nl.__send__(:*)
702
+ ).__send__(
703
+ :+,
704
+ ::Myco.find_constant(:T).reopen.__send__(
705
+ :[],
706
+ :tb
707
+ )
708
+ ).__send__(
709
+ :+,
710
+ ::Myco.find_constant(:C).spc_nl.__send__(:*)
711
+ ).__send__(
712
+ :+,
713
+ ::Myco.find_constant(:T).declare_begin
714
+ ).__send__(
715
+ :+,
716
+ self.declobj_expr_body.__send__(
717
+ :[],
718
+ :n1
719
+ )
720
+ )) { |*| (self.ast.copen(
721
+ self.tb,
722
+ self.__send__(:n0),
723
+ self.__send__(:n1)
724
+ ))})}
725
+ )
726
+ declare_meme(
727
+ :cdefn,
728
+ [:rule],
729
+ ::Object::Proc.new { |*| (self.r(self.constant.__send__(
691
730
  :[],
692
- :rhs
693
- )
694
- )) { || (self.ast.lasgn(
695
- self.to,
696
- self.ti.sym,
697
- self.rhs
698
- ))})}
699
- declare_meme(:invoke_assignment_lhs, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.left_chained_invocations.__send__(
700
- :/,
701
- self.invoke
702
- ))}
703
- declare_meme(:invoke_assignment, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.invoke_assignment_lhs.__send__(
704
- :[],
705
- :lhs
706
- ).__send__(
707
- :+,
708
- ::Myco.find_constant(:C).spc_nl.__send__(:*)
709
- ).__send__(
710
- :+,
711
- ::Myco.find_constant(:T).assign.__send__(
731
+ :n0
732
+ ).__send__(
733
+ :+,
734
+ ::Myco.find_constant(:C).spc_nl.__send__(:*)
735
+ ).__send__(
736
+ :+,
737
+ ::Myco.find_constant(:T).define.__send__(
738
+ :[],
739
+ :tb
740
+ )
741
+ ).__send__(
742
+ :+,
743
+ ::Myco.find_constant(:C).spc_nl.__send__(:*)
744
+ ).__send__(
745
+ :+,
746
+ self.declobj.__send__(
747
+ :[],
748
+ :n1
749
+ )
750
+ )) { |*| (self.ast.cdefn(
751
+ self.tb,
752
+ self.__send__(:n0),
753
+ self.__send__(:n1)
754
+ ))})}
755
+ )
756
+ declare_meme(
757
+ :declstr_body,
758
+ [:rule],
759
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).declstr_begin.__send__(
712
760
  :[],
713
- :to
714
- )
715
- ).__send__(
716
- :+,
717
- ::Myco.find_constant(:C).spc_nl.__send__(:*)
718
- ).__send__(
719
- :+,
720
- self.assign_rhs.__send__(
761
+ :tb
762
+ ).__send__(
763
+ :+,
764
+ ::Myco.find_constant(:C).spc.__send__(:*)
765
+ ).__send__(
766
+ :+,
767
+ ::Myco.find_constant(:C).nl
768
+ ).__send__(
769
+ :+,
770
+ ::Myco.find_constant(:T).declstr_body.__send__(
771
+ :[],
772
+ :ts
773
+ )
774
+ ).__send__(
775
+ :+,
776
+ ::Myco.find_constant(:C).spc_nl.__send__(:*)
777
+ ).__send__(
778
+ :+,
779
+ ::Myco.find_constant(:T).declstr_end
780
+ )) { |*| (self.ast.str(
781
+ self.tb,
782
+ self.ts.text
783
+ ))})}
784
+ )
785
+ declare_meme(
786
+ :declstr,
787
+ [:rule],
788
+ ::Object::Proc.new { |*| (self.r(self.constant_list.__send__(
789
+ :[],
790
+ :nc
791
+ ).__send__(
792
+ :+,
793
+ ::Myco.find_constant(:C).spc.__send__(:+)
794
+ ).__send__(
795
+ :+,
796
+ self.declstr_body.__send__(
797
+ :[],
798
+ :nb
799
+ )
800
+ )) { |*| (self.ast.declstr(
801
+ self.nc,
802
+ self.nc,
803
+ self.nb
804
+ ))})}
805
+ )
806
+ declare_meme(
807
+ :assignment,
808
+ [:rule],
809
+ ::Object::Proc.new { |*| (self.local_assignment.__send__(
810
+ :/,
811
+ self.invoke_assignment
812
+ ))}
813
+ )
814
+ declare_meme(
815
+ :assign_rhs,
816
+ [:rule],
817
+ ::Object::Proc.new { |*| (self.arg_expr)}
818
+ )
819
+ declare_meme(
820
+ :local_assignment,
821
+ [:rule],
822
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).identifier.__send__(
721
823
  :[],
722
- :rhs
723
- )
724
- )) { || (
725
- self.lhs.__send__(
726
- :name=,
727
- "#{self.lhs.name}=".to_sym
728
- )
729
- orig_arguments = ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.lhs.arguments) {self.lhs.arguments.body}) {[]}
730
- arg_order = ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.lhs.name.__send__(
731
- :==,
732
- :[]=
733
- )) {[
734
- *orig_arguments,
824
+ :ti
825
+ ).__send__(
826
+ :+,
827
+ ::Myco.find_constant(:C).spc_nl.__send__(:*)
828
+ ).__send__(
829
+ :+,
830
+ ::Myco.find_constant(:T).assign.__send__(
831
+ :[],
832
+ :to
833
+ )
834
+ ).__send__(
835
+ :+,
836
+ ::Myco.find_constant(:C).spc_nl.__send__(:*)
837
+ ).__send__(
838
+ :+,
839
+ self.assign_rhs.__send__(
840
+ :[],
841
+ :rhs
842
+ )
843
+ )) { |*| (self.ast.lasgn(
844
+ self.to,
845
+ self.ti.sym,
735
846
  self.rhs
736
- ]}) {[
737
- self.rhs,
738
- *orig_arguments
739
- ]}
740
- self.lhs.__send__(
741
- :arguments=,
742
- self.ast.args(
743
- self.rhs,
744
- arg_order
745
- )
746
- )
747
- self.lhs
748
- )})}
749
- declare_meme(:opt_arg_list, [], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:C).spc.__send__(:*).__send__(
750
- :+,
751
- self.arg_list.__send__(
752
- :[],
753
- :n
754
- )
755
- )) { || (self.n)}.__send__(:-))}
756
- declare_meme(:opt_block_body, [], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:C).spc_nl.__send__(:*).__send__(
757
- :+,
758
- self.block_body.__send__(
759
- :[],
760
- :n
761
- )
762
- )) { || (self.n)}.__send__(:-))}
763
- declare_meme(:invoke, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).identifier.__send__(
764
- :[],
765
- :tn
766
- ).__send__(
767
- :+,
768
- self.opt_arg_list.__send__(
769
- :[],
770
- :na
771
- )
772
- ).__send__(
773
- :+,
774
- self.opt_block_body.__send__(
775
- :[],
776
- :nb
777
- )
778
- )) { || (self.ast.invoke(
779
- self.tn,
780
- nil,
781
- self.tn.sym,
782
- self.na,
783
- self.nb
784
- ))})}
785
- declare_meme(:invoke_classic_form, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).identifier.__send__(
786
- :[],
787
- :tn
788
- ).__send__(
789
- :+,
790
- ::Myco.find_constant(:C).spc.__send__(:*)
791
- ).__send__(
792
- :+,
793
- self.arg_list.__send__(
847
+ ))})}
848
+ )
849
+ declare_meme(
850
+ :invoke_assignment_lhs,
851
+ [:rule],
852
+ ::Object::Proc.new { |*| (self.left_chained_invocations.__send__(
853
+ :/,
854
+ self.invoke
855
+ ))}
856
+ )
857
+ declare_meme(
858
+ :invoke_assignment,
859
+ [:rule],
860
+ ::Object::Proc.new { |*| (self.r(self.invoke_assignment_lhs.__send__(
794
861
  :[],
795
- :na
796
- )
797
- )) { || (self.ast.invoke(
798
- self.tn,
799
- nil,
800
- self.tn.sym,
801
- self.na,
802
- nil
803
- ))})}
804
- declare_meme(:op_invoke, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.op_invoke_id.__send__(
805
- :[],
806
- :tn
807
- ).__send__(
808
- :+,
809
- self.opt_arg_list.__send__(
862
+ :lhs
863
+ ).__send__(
864
+ :+,
865
+ ::Myco.find_constant(:C).spc_nl.__send__(:*)
866
+ ).__send__(
867
+ :+,
868
+ ::Myco.find_constant(:T).assign.__send__(
869
+ :[],
870
+ :to
871
+ )
872
+ ).__send__(
873
+ :+,
874
+ ::Myco.find_constant(:C).spc_nl.__send__(:*)
875
+ ).__send__(
876
+ :+,
877
+ self.assign_rhs.__send__(
878
+ :[],
879
+ :rhs
880
+ )
881
+ )) { |*| (
882
+ self.lhs.__send__(
883
+ :name=,
884
+ "#{self.lhs.name}=".to_sym
885
+ )
886
+ orig_arguments = ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.lhs.arguments) {self.lhs.arguments.body}) {[]}
887
+ arg_order = ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.lhs.name.__send__(
888
+ :==,
889
+ :[]=
890
+ )) {[
891
+ *orig_arguments,
892
+ self.rhs
893
+ ]}) {[
894
+ self.rhs,
895
+ *orig_arguments
896
+ ]}
897
+ self.lhs.__send__(
898
+ :arguments=,
899
+ self.ast.args(
900
+ self.rhs,
901
+ arg_order
902
+ )
903
+ )
904
+ self.lhs
905
+ )})}
906
+ )
907
+ declare_meme(
908
+ :opt_arg_list,
909
+ [],
910
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:C).spc.__send__(:*).__send__(
911
+ :+,
912
+ self.arg_list.__send__(
913
+ :[],
914
+ :n
915
+ )
916
+ )) { |*| (self.n)}.__send__(:-))}
917
+ )
918
+ declare_meme(
919
+ :opt_block_body,
920
+ [],
921
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:C).spc_nl.__send__(:*).__send__(
922
+ :+,
923
+ self.block_body.__send__(
924
+ :[],
925
+ :n
926
+ )
927
+ )) { |*| (self.n)}.__send__(:-))}
928
+ )
929
+ declare_meme(
930
+ :invoke,
931
+ [:rule],
932
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).identifier.__send__(
933
+ :[],
934
+ :tn
935
+ ).__send__(
936
+ :+,
937
+ self.opt_arg_list.__send__(
938
+ :[],
939
+ :na
940
+ )
941
+ ).__send__(
942
+ :+,
943
+ self.opt_block_body.__send__(
944
+ :[],
945
+ :nb
946
+ )
947
+ )) { |*| (self.ast.invoke(
948
+ self.tn,
949
+ nil,
950
+ self.tn.sym,
951
+ self.na,
952
+ self.nb
953
+ ))})}
954
+ )
955
+ declare_meme(
956
+ :invoke_classic_form,
957
+ [:rule],
958
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).identifier.__send__(
959
+ :[],
960
+ :tn
961
+ ).__send__(
962
+ :+,
963
+ ::Myco.find_constant(:C).spc.__send__(:*)
964
+ ).__send__(
965
+ :+,
966
+ self.arg_list.__send__(
967
+ :[],
968
+ :na
969
+ )
970
+ )) { |*| (self.ast.invoke(
971
+ self.tn,
972
+ nil,
973
+ self.tn.sym,
974
+ self.na,
975
+ nil
976
+ ))})}
977
+ )
978
+ declare_meme(
979
+ :op_invoke,
980
+ [:rule],
981
+ ::Object::Proc.new { |*| (self.r(self.op_invoke_id.__send__(
982
+ :[],
983
+ :tn
984
+ ).__send__(
985
+ :+,
986
+ self.opt_arg_list.__send__(
987
+ :[],
988
+ :na
989
+ )
990
+ ).__send__(
991
+ :+,
992
+ self.opt_block_body.__send__(
993
+ :[],
994
+ :nb
995
+ )
996
+ )) { |*| (self.ast.invoke(
997
+ self.tn,
998
+ nil,
999
+ self.tn.sym,
1000
+ self.na,
1001
+ self.nb
1002
+ ))})}
1003
+ )
1004
+ declare_meme(
1005
+ :elem_invoke,
1006
+ [:rule],
1007
+ ::Object::Proc.new { |*| (self.r(self.lit_array.__send__(
810
1008
  :[],
811
1009
  :na
812
- )
813
- ).__send__(
814
- :+,
815
- self.opt_block_body.__send__(
1010
+ ).__send__(
1011
+ :+,
1012
+ self.opt_block_body.__send__(
1013
+ :[],
1014
+ :nb
1015
+ )
1016
+ )) { |*| (self.ast.invoke(
1017
+ self.na,
1018
+ nil,
816
1019
  :[],
817
- :nb
818
- )
819
- )) { || (self.ast.invoke(
820
- self.tn,
821
- nil,
822
- self.tn.sym,
823
- self.na,
824
- self.nb
825
- ))})}
826
- declare_meme(:elem_invoke, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.lit_array.__send__(
827
- :[],
828
- :na
829
- ).__send__(
830
- :+,
831
- self.opt_block_body.__send__(
1020
+ self.ast.args(
1021
+ self.na,
1022
+ self.na.body
1023
+ ),
1024
+ self.nb
1025
+ ))})}
1026
+ )
1027
+ declare_meme(
1028
+ :op_invoke_id,
1029
+ [:rule],
1030
+ ::Object::Proc.new { |*| (self.left_op_normal)}
1031
+ )
1032
+ declare_meme(
1033
+ :arg_sep,
1034
+ [],
1035
+ ::Object::Proc.new { |*| (::Myco.find_constant(:C).spc.__send__(:*).__send__(
1036
+ :+,
1037
+ ::Myco.find_constant(:T).arg_sep
1038
+ ).__send__(
1039
+ :+,
1040
+ ::Myco.find_constant(:C).spc.__send__(:*)
1041
+ ).__send__(:+))}
1042
+ )
1043
+ declare_meme(
1044
+ :arg_sep_opt,
1045
+ [],
1046
+ ::Object::Proc.new { |*| (::Myco.find_constant(:C).spc.__send__(
1047
+ :/,
1048
+ ::Myco.find_constant(:T).arg_sep
1049
+ ).__send__(:*))}
1050
+ )
1051
+ declare_meme(
1052
+ :in_arg_normal,
1053
+ [:rule],
1054
+ ::Object::Proc.new { |*| (self.in_arg_splat.__send__(
1055
+ :/,
1056
+ self.r(self.arg_expr.__send__(
1057
+ :[],
1058
+ :n0
1059
+ ).__send__(
1060
+ :+,
1061
+ self.in_arg_kwarg_mark.__send__(:!)
1062
+ )) { |*| (self.__send__(:n0))}
1063
+ ))}
1064
+ )
1065
+ declare_meme(
1066
+ :in_arg_sepd_normal,
1067
+ [:rule],
1068
+ ::Object::Proc.new { |*| (self.r(self.arg_sep.__send__(
1069
+ :+,
1070
+ self.in_arg_normal.__send__(
1071
+ :[],
1072
+ :n0
1073
+ )
1074
+ )) { |*| (self.__send__(:n0))})}
1075
+ )
1076
+ declare_meme(
1077
+ :in_arg_normals,
1078
+ [:rule],
1079
+ ::Object::Proc.new { |*| (self.r(self.in_arg_normal.__send__(
832
1080
  :[],
833
- :nb
834
- )
835
- )) { || (self.ast.invoke(
836
- self.na,
837
- nil,
838
- :[],
839
- self.ast.args(
840
- self.na,
841
- self.na.body
842
- ),
843
- self.nb
844
- ))})}
845
- declare_meme(:op_invoke_id, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.left_op_normal)}
846
- declare_meme(:arg_sep, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:C).spc.__send__(:*).__send__(
847
- :+,
848
- ::Myco.find_constant(:T).arg_sep
849
- ).__send__(
850
- :+,
851
- ::Myco.find_constant(:C).spc.__send__(:*)
852
- ).__send__(:+))}
853
- declare_meme(:arg_sep_opt, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:C).spc.__send__(
854
- :/,
855
- ::Myco.find_constant(:T).arg_sep
856
- ).__send__(:*))}
857
- declare_meme(:in_arg_normal, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.in_arg_splat.__send__(
858
- :/,
859
- self.r(self.arg_expr.__send__(
1081
+ :n0
1082
+ ).__send__(
1083
+ :+,
1084
+ self.in_arg_sepd_normal.__send__(:*).__send__(
1085
+ :[],
1086
+ :nrest
1087
+ )
1088
+ )) { |*| ([
1089
+ self.__send__(:n0),
1090
+ *self.nrest
1091
+ ])})}
1092
+ )
1093
+ declare_meme(
1094
+ :in_arg_sepd_kwarg,
1095
+ [:rule],
1096
+ ::Object::Proc.new { |*| (self.r(self.arg_sep.__send__(
1097
+ :+,
1098
+ self.in_arg_kwarg.__send__(
1099
+ :[],
1100
+ :n0
1101
+ )
1102
+ )) { |*| (self.__send__(:n0))})}
1103
+ )
1104
+ declare_meme(
1105
+ :in_arg_kwargs,
1106
+ [:rule],
1107
+ ::Object::Proc.new { |*| (self.r(self.in_arg_kwarg.__send__(
860
1108
  :[],
861
1109
  :n0
862
1110
  ).__send__(
863
1111
  :+,
864
- self.in_arg_kwarg_mark.__send__(:!)
865
- )) { || (self.__send__(:n0))}
866
- ))}
867
- declare_meme(:in_arg_sepd_normal, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.arg_sep.__send__(
868
- :+,
869
- self.in_arg_normal.__send__(
1112
+ self.in_arg_sepd_kwarg.__send__(:*).__send__(
1113
+ :[],
1114
+ :nrest
1115
+ )
1116
+ )) { |*| (self.ast.hash(
1117
+ self.__send__(:n0).first,
1118
+ [
1119
+ self.__send__(:n0),
1120
+ *self.nrest
1121
+ ].flatten
1122
+ ))})}
1123
+ )
1124
+ declare_meme(
1125
+ :in_arg_kwarg_mark,
1126
+ [:rule],
1127
+ ::Object::Proc.new { |*| (::Myco.find_constant(:C).spc_nl.__send__(:*).__send__(
1128
+ :+,
1129
+ ::Myco.find_constant(:T).meme_mark
1130
+ ))}
1131
+ )
1132
+ declare_meme(
1133
+ :in_arg_kwarg,
1134
+ [:rule],
1135
+ ::Object::Proc.new { |*| (self.r(self.id_as_symbol.__send__(
870
1136
  :[],
871
1137
  :n0
872
- )
873
- )) { || (self.__send__(:n0))})}
874
- declare_meme(:in_arg_normals, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.in_arg_normal.__send__(
875
- :[],
876
- :n0
877
- ).__send__(
878
- :+,
879
- self.in_arg_sepd_normal.__send__(:*).__send__(
1138
+ ).__send__(
1139
+ :+,
1140
+ self.in_arg_kwarg_mark
1141
+ ).__send__(
1142
+ :+,
1143
+ ::Myco.find_constant(:C).spc_nl.__send__(:*)
1144
+ ).__send__(
1145
+ :+,
1146
+ self.arg_expr.__send__(
1147
+ :[],
1148
+ :n1
1149
+ )
1150
+ )) { |*| ([
1151
+ self.__send__(:n0),
1152
+ self.__send__(:n1)
1153
+ ])})}
1154
+ )
1155
+ declare_meme(
1156
+ :in_arg_splat,
1157
+ [:rule],
1158
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).op_mult.__send__(
880
1159
  :[],
881
- :nrest
882
- )
883
- )) { || ([
884
- self.__send__(:n0),
885
- *self.nrest
886
- ])})}
887
- declare_meme(:in_arg_sepd_kwarg, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.arg_sep.__send__(
888
- :+,
889
- self.in_arg_kwarg.__send__(
1160
+ :to
1161
+ ).__send__(
1162
+ :+,
1163
+ self.expr_atom.__send__(
1164
+ :[],
1165
+ :n0
1166
+ )
1167
+ )) { |*| (self.ast.splat(
1168
+ self.to,
1169
+ self.__send__(:n0)
1170
+ ))})}
1171
+ )
1172
+ declare_meme(
1173
+ :in_arg_block,
1174
+ [:rule],
1175
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).op_toproc.__send__(
1176
+ :[],
1177
+ :to
1178
+ ).__send__(
1179
+ :+,
1180
+ self.expr_atom.__send__(
1181
+ :[],
1182
+ :n0
1183
+ )
1184
+ )) { |*| (self.ast.blkarg(
1185
+ self.to,
1186
+ self.__send__(:n0)
1187
+ ))})}
1188
+ )
1189
+ declare_meme(
1190
+ :in_arg_list,
1191
+ [:rule],
1192
+ ::Object::Proc.new { |*| (self.r(self.in_arg_normals.__send__(
890
1193
  :[],
891
1194
  :n0
892
- )
893
- )) { || (self.__send__(:n0))})}
894
- declare_meme(:in_arg_kwargs, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.in_arg_kwarg.__send__(
895
- :[],
896
- :n0
897
- ).__send__(
898
- :+,
899
- self.in_arg_sepd_kwarg.__send__(:*).__send__(
1195
+ ).__send__(
1196
+ :+,
1197
+ self.arg_sep
1198
+ ).__send__(
1199
+ :+,
1200
+ self.in_arg_kwargs.__send__(
1201
+ :[],
1202
+ :n1
1203
+ )
1204
+ ).__send__(
1205
+ :+,
1206
+ self.arg_sep
1207
+ ).__send__(
1208
+ :+,
1209
+ self.in_arg_block.__send__(
1210
+ :[],
1211
+ :n2
1212
+ )
1213
+ )) { |*| ([
1214
+ *self.__send__(:n0),
1215
+ self.__send__(:n1),
1216
+ self.__send__(:n2)
1217
+ ])}.__send__(
1218
+ :/,
1219
+ self.r(self.in_arg_normals.__send__(
1220
+ :[],
1221
+ :n0
1222
+ ).__send__(
1223
+ :+,
1224
+ self.arg_sep
1225
+ ).__send__(
1226
+ :+,
1227
+ self.in_arg_kwargs.__send__(
1228
+ :[],
1229
+ :n1
1230
+ )
1231
+ )) { |*| ([
1232
+ *self.__send__(:n0),
1233
+ self.__send__(:n1)
1234
+ ])}
1235
+ ).__send__(
1236
+ :/,
1237
+ self.r(self.in_arg_normals.__send__(
1238
+ :[],
1239
+ :n0
1240
+ ).__send__(
1241
+ :+,
1242
+ self.arg_sep
1243
+ ).__send__(
1244
+ :+,
1245
+ self.in_arg_block.__send__(
1246
+ :[],
1247
+ :n1
1248
+ )
1249
+ )) { |*| ([
1250
+ *self.__send__(:n0),
1251
+ self.__send__(:n1)
1252
+ ])}
1253
+ ).__send__(
1254
+ :/,
1255
+ self.r(self.in_arg_kwargs.__send__(
1256
+ :[],
1257
+ :n0
1258
+ ).__send__(
1259
+ :+,
1260
+ self.arg_sep
1261
+ ).__send__(
1262
+ :+,
1263
+ self.in_arg_block.__send__(
1264
+ :[],
1265
+ :n1
1266
+ )
1267
+ )) { |*| ([
1268
+ self.__send__(:n0),
1269
+ self.__send__(:n1)
1270
+ ])}
1271
+ ).__send__(
1272
+ :/,
1273
+ self.r(self.in_arg_normals.__send__(
1274
+ :[],
1275
+ :n0
1276
+ )) { |*| ([*self.__send__(:n0)])}
1277
+ ).__send__(
1278
+ :/,
1279
+ self.r(self.in_arg_kwargs.__send__(
1280
+ :[],
1281
+ :n0
1282
+ )) { |*| ([self.__send__(:n0)])}
1283
+ ).__send__(
1284
+ :/,
1285
+ self.r(self.in_arg_block.__send__(
1286
+ :[],
1287
+ :n0
1288
+ )) { |*| ([self.__send__(:n0)])}
1289
+ ))}
1290
+ )
1291
+ declare_meme(
1292
+ :arg_list,
1293
+ [:rule],
1294
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).args_begin.__send__(
900
1295
  :[],
901
- :nrest
902
- )
903
- )) { || (self.ast.hash(
904
- self.__send__(:n0).first,
905
- [
906
- self.__send__(:n0),
907
- *self.nrest
908
- ].flatten
909
- ))})}
910
- declare_meme(:in_arg_kwarg_mark, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:C).spc_nl.__send__(:*).__send__(
911
- :+,
912
- ::Myco.find_constant(:T).meme_mark
913
- ))}
914
- declare_meme(:in_arg_kwarg, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.id_as_symbol.__send__(
915
- :[],
916
- :n0
917
- ).__send__(
918
- :+,
919
- self.in_arg_kwarg_mark
920
- ).__send__(
921
- :+,
922
- ::Myco.find_constant(:C).spc_nl.__send__(:*)
923
- ).__send__(
924
- :+,
925
- self.arg_expr.__send__(
1296
+ :tb
1297
+ ).__send__(
1298
+ :+,
1299
+ self.arg_sep_opt
1300
+ ).__send__(
1301
+ :+,
1302
+ self.in_arg_list.__send__(:-).__send__(
1303
+ :[],
1304
+ :nlist
1305
+ )
1306
+ ).__send__(
1307
+ :+,
1308
+ self.arg_sep_opt
1309
+ ).__send__(
1310
+ :+,
1311
+ ::Myco.find_constant(:T).args_end
1312
+ )) { |*| (self.ast.args(
1313
+ self.tb,
1314
+ ::Myco.branch_op(:"||", self.nlist) {[]}
1315
+ ))})}
1316
+ )
1317
+ declare_meme(
1318
+ :lit_array,
1319
+ [:rule],
1320
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).array_begin.__send__(
926
1321
  :[],
927
- :n1
928
- )
929
- )) { || ([
930
- self.__send__(:n0),
931
- self.__send__(:n1)
932
- ])})}
933
- declare_meme(:in_arg_splat, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).op_mult.__send__(
934
- :[],
935
- :to
936
- ).__send__(
937
- :+,
938
- self.expr_atom.__send__(
1322
+ :tb
1323
+ ).__send__(
1324
+ :+,
1325
+ self.arg_sep_opt
1326
+ ).__send__(
1327
+ :+,
1328
+ self.in_arg_list.__send__(:-).__send__(
1329
+ :[],
1330
+ :nlist
1331
+ )
1332
+ ).__send__(
1333
+ :+,
1334
+ self.arg_sep_opt
1335
+ ).__send__(
1336
+ :+,
1337
+ ::Myco.find_constant(:T).array_end
1338
+ )) { |*| (self.ast.array(
1339
+ self.tb,
1340
+ ::Myco.branch_op(:"||", self.nlist) {[]}
1341
+ ))})}
1342
+ )
1343
+ declare_meme(
1344
+ :param_sep,
1345
+ [],
1346
+ ::Object::Proc.new { |*| (::Myco.find_constant(:C).spc.__send__(:*).__send__(
1347
+ :+,
1348
+ ::Myco.find_constant(:T).arg_sep
1349
+ ).__send__(
1350
+ :+,
1351
+ ::Myco.find_constant(:C).spc.__send__(:*)
1352
+ ).__send__(:+).__send__(
1353
+ :/,
1354
+ ::Myco.find_constant(:C).spc.__send__(:*).__send__(
1355
+ :+,
1356
+ ::Myco.find_constant(:T).params_end.__send__(:!).__send__(:!)
1357
+ )
1358
+ ))}
1359
+ )
1360
+ declare_meme(
1361
+ :param_sep_opt,
1362
+ [],
1363
+ ::Object::Proc.new { |*| (::Myco.find_constant(:C).spc.__send__(
1364
+ :/,
1365
+ ::Myco.find_constant(:T).arg_sep
1366
+ ).__send__(:*))}
1367
+ )
1368
+ declare_meme(
1369
+ :param_sepd,
1370
+ [],
1371
+ ::Object::Proc.new { |x| (self.r(x.__send__(
939
1372
  :[],
940
1373
  :n0
941
- )
942
- )) { || (self.ast.splat(
943
- self.to,
944
- self.__send__(:n0)
945
- ))})}
946
- declare_meme(:in_arg_block, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).op_toproc.__send__(
947
- :[],
948
- :to
949
- ).__send__(
950
- :+,
951
- self.expr_atom.__send__(
1374
+ ).__send__(
1375
+ :+,
1376
+ self.param_sep
1377
+ )) { |*| (self.__send__(:n0))})}
1378
+ )
1379
+ declare_meme(
1380
+ :req_param,
1381
+ [:rule],
1382
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).identifier.__send__(
952
1383
  :[],
953
- :n0
954
- )
955
- )) { || (self.ast.blkarg(
956
- self.to,
957
- self.__send__(:n0)
958
- ))})}
959
- declare_meme(:in_arg_list, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.in_arg_normals.__send__(
960
- :[],
961
- :n0
962
- ).__send__(
963
- :+,
964
- self.arg_sep
965
- ).__send__(
966
- :+,
967
- self.in_arg_kwargs.__send__(
1384
+ :ti
1385
+ ).__send__(
1386
+ :+,
1387
+ self.param_sep.__send__(:!).__send__(:!)
1388
+ )) { |*| (self.ast.reqprm(
1389
+ self.ti,
1390
+ self.ti.sym
1391
+ ))})}
1392
+ )
1393
+ declare_meme(
1394
+ :opt_param,
1395
+ [:rule],
1396
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).identifier.__send__(
968
1397
  :[],
969
- :n1
970
- )
971
- ).__send__(
972
- :+,
973
- self.arg_sep
974
- ).__send__(
975
- :+,
976
- self.in_arg_block.__send__(
1398
+ :ti
1399
+ ).__send__(
1400
+ :+,
1401
+ ::Myco.find_constant(:C).spc_nl.__send__(:*)
1402
+ ).__send__(
1403
+ :+,
1404
+ ::Myco.find_constant(:T).assign.__send__(
1405
+ :[],
1406
+ :to
1407
+ )
1408
+ ).__send__(
1409
+ :+,
1410
+ ::Myco.find_constant(:C).spc_nl.__send__(:*)
1411
+ ).__send__(
1412
+ :+,
1413
+ self.arg_expr.__send__(
1414
+ :[],
1415
+ :nv
1416
+ )
1417
+ )) { |*| (self.ast.optprm(
1418
+ self.ti,
1419
+ self.ti.sym,
1420
+ self.nv
1421
+ ))})}
1422
+ )
1423
+ declare_meme(
1424
+ :rest_param,
1425
+ [:rule],
1426
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).op_mult.__send__(
1427
+ :+,
1428
+ ::Myco.find_constant(:C).spc_nl.__send__(:*)
1429
+ ).__send__(
1430
+ :+,
1431
+ ::Myco.find_constant(:T).identifier.__send__(
1432
+ :[],
1433
+ :ti
1434
+ )
1435
+ )) { |*| (self.ast.restprm(
1436
+ self.ti,
1437
+ self.ti.sym
1438
+ ))})}
1439
+ )
1440
+ declare_meme(
1441
+ :kwopt_param,
1442
+ [:rule],
1443
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).identifier.__send__(
1444
+ :[],
1445
+ :ti
1446
+ ).__send__(
1447
+ :+,
1448
+ ::Myco.find_constant(:C).spc_nl.__send__(:*)
1449
+ ).__send__(
1450
+ :+,
1451
+ ::Myco.find_constant(:T).meme_mark.__send__(
1452
+ :[],
1453
+ :to
1454
+ )
1455
+ ).__send__(
1456
+ :+,
1457
+ ::Myco.find_constant(:C).spc_nl.__send__(:*)
1458
+ ).__send__(
1459
+ :+,
1460
+ self.arg_expr.__send__(
1461
+ :[],
1462
+ :nv
1463
+ )
1464
+ )) { |*| (self.ast.kwoptprm(
1465
+ self.ti,
1466
+ self.ti.sym,
1467
+ self.nv
1468
+ ))})}
1469
+ )
1470
+ declare_meme(
1471
+ :kwreq_param,
1472
+ [:rule],
1473
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).identifier.__send__(
977
1474
  :[],
978
- :n2
979
- )
980
- )) { || ([
981
- *self.__send__(:n0),
982
- self.__send__(:n1),
983
- self.__send__(:n2)
984
- ])}.__send__(
985
- :/,
986
- self.r(self.in_arg_normals.__send__(
1475
+ :ti
1476
+ ).__send__(
1477
+ :+,
1478
+ ::Myco.find_constant(:C).spc_nl.__send__(:*)
1479
+ ).__send__(
1480
+ :+,
1481
+ ::Myco.find_constant(:T).meme_mark.__send__(
1482
+ :[],
1483
+ :to
1484
+ )
1485
+ ).__send__(
1486
+ :+,
1487
+ self.param_sep.__send__(:!).__send__(:!)
1488
+ )) { |*| (self.ast.kwreqprm(
1489
+ self.ti,
1490
+ self.ti.sym
1491
+ ))})}
1492
+ )
1493
+ declare_meme(
1494
+ :kwrest_param,
1495
+ [:rule],
1496
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).op_exp.__send__(
1497
+ :+,
1498
+ ::Myco.find_constant(:C).spc_nl.__send__(:*)
1499
+ ).__send__(
1500
+ :+,
1501
+ ::Myco.find_constant(:T).identifier.__send__(
1502
+ :[],
1503
+ :ti
1504
+ )
1505
+ )) { |*| (self.ast.kwrestprm(
1506
+ self.ti,
1507
+ self.ti.sym
1508
+ ))})}
1509
+ )
1510
+ declare_meme(
1511
+ :block_param,
1512
+ [:rule],
1513
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).op_toproc.__send__(
1514
+ :+,
1515
+ ::Myco.find_constant(:C).spc_nl.__send__(:*)
1516
+ ).__send__(
1517
+ :+,
1518
+ ::Myco.find_constant(:T).identifier.__send__(
1519
+ :[],
1520
+ :ti
1521
+ )
1522
+ )) { |*| (self.ast.blkprm(
1523
+ self.ti,
1524
+ self.ti.sym
1525
+ ))})}
1526
+ )
1527
+ declare_meme(
1528
+ :param_list,
1529
+ [:rule],
1530
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).params_begin.__send__(
987
1531
  :[],
988
- :n0
1532
+ :tb
1533
+ ).__send__(
1534
+ :+,
1535
+ self.param_sep_opt
1536
+ ).__send__(
1537
+ :+,
1538
+ self.param_sepd(self.req_param).__send__(:*).__send__(
1539
+ :[],
1540
+ :required
1541
+ )
1542
+ ).__send__(
1543
+ :+,
1544
+ self.param_sepd(self.opt_param).__send__(:*).__send__(
1545
+ :[],
1546
+ :optional
1547
+ )
1548
+ ).__send__(
1549
+ :+,
1550
+ self.param_sepd(self.rest_param).__send__(:-).__send__(
1551
+ :[],
1552
+ :rest
1553
+ )
1554
+ ).__send__(
1555
+ :+,
1556
+ self.param_sepd(self.req_param).__send__(:*).__send__(
1557
+ :[],
1558
+ :post
1559
+ )
1560
+ ).__send__(
1561
+ :+,
1562
+ self.param_sepd(self.kwreq_param.__send__(
1563
+ :/,
1564
+ self.kwopt_param
1565
+ )).__send__(:*).__send__(
1566
+ :[],
1567
+ :kw
1568
+ )
1569
+ ).__send__(
1570
+ :+,
1571
+ self.param_sepd(self.kwrest_param).__send__(:-).__send__(
1572
+ :[],
1573
+ :kwrest
1574
+ )
1575
+ ).__send__(
1576
+ :+,
1577
+ self.param_sepd(self.block_param).__send__(:-).__send__(
1578
+ :[],
1579
+ :block
1580
+ )
1581
+ ).__send__(
1582
+ :+,
1583
+ ::Myco.find_constant(:T).params_end
1584
+ )) { |*| (
1585
+ kwrequired = self.kw.select { |x| (x.node_type.__send__(
1586
+ :==,
1587
+ :kwreqprm
1588
+ ))}
1589
+ kwoptional = self.kw.select { |x| (x.node_type.__send__(
1590
+ :==,
1591
+ :kwoptprm
1592
+ ))}
1593
+ self.ast.params(
1594
+ self.tb,
1595
+ self.required,
1596
+ self.optional,
1597
+ ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.rest.__send__(
1598
+ :is_a?,
1599
+ ::Myco.find_constant(:Array)
1600
+ )) {self.rest.first}) {self.rest},
1601
+ self.post,
1602
+ kwrequired,
1603
+ kwoptional,
1604
+ ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.kwrest.__send__(
1605
+ :is_a?,
1606
+ ::Myco.find_constant(:Array)
1607
+ )) {self.kwrest.first}) {self.kwrest},
1608
+ ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.block.__send__(
1609
+ :is_a?,
1610
+ ::Myco.find_constant(:Array)
1611
+ )) {self.block.first}) {self.block}
1612
+ )
1613
+ )})}
1614
+ )
1615
+ declare_meme(
1616
+ :left_op_normal,
1617
+ [],
1618
+ ::Object::Proc.new { |*| (::Myco.find_constant(:T).op_exp.__send__(
1619
+ :/,
1620
+ ::Myco.find_constant(:T).op_mult
1621
+ ).__send__(
1622
+ :/,
1623
+ ::Myco.find_constant(:T).op_div
1624
+ ).__send__(
1625
+ :/,
1626
+ ::Myco.find_constant(:T).op_mod
1627
+ ).__send__(
1628
+ :/,
1629
+ ::Myco.find_constant(:T).op_plus
1630
+ ).__send__(
1631
+ :/,
1632
+ ::Myco.find_constant(:T).op_minus
1633
+ ).__send__(
1634
+ :/,
1635
+ ::Myco.find_constant(:T).op_compare
1636
+ ).__send__(
1637
+ :/,
1638
+ ::Myco.find_constant(:T).op_r_pipe
1639
+ ))}
1640
+ )
1641
+ declare_meme(
1642
+ :left_op_branch,
1643
+ [],
1644
+ ::Object::Proc.new { |*| (::Myco.find_constant(:T).op_and.__send__(
1645
+ :/,
1646
+ ::Myco.find_constant(:T).op_or
1647
+ ).__send__(
1648
+ :/,
1649
+ ::Myco.find_constant(:T).op_and_q
1650
+ ).__send__(
1651
+ :/,
1652
+ ::Myco.find_constant(:T).op_or_q
1653
+ ).__send__(
1654
+ :/,
1655
+ ::Myco.find_constant(:T).op_void_q
1656
+ ))}
1657
+ )
1658
+ declare_meme(
1659
+ :left_op,
1660
+ [:rule],
1661
+ ::Object::Proc.new { |*| (self.left_op_normal.__send__(
1662
+ :/,
1663
+ self.left_op_branch
1664
+ ))}
1665
+ )
1666
+ declare_meme(
1667
+ :sepd_chained_operation,
1668
+ [:rule],
1669
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:C).spc_nl.__send__(:*).__send__(
1670
+ :+,
1671
+ self.left_op.__send__(
1672
+ :[],
1673
+ :to
1674
+ )
989
1675
  ).__send__(
990
1676
  :+,
991
- self.arg_sep
1677
+ ::Myco.find_constant(:C).spc_nl.__send__(:*)
992
1678
  ).__send__(
993
1679
  :+,
994
- self.in_arg_kwargs.__send__(
1680
+ self.expr_atom.__send__(
995
1681
  :[],
996
1682
  :n1
997
1683
  )
998
- )) { || ([
999
- *self.__send__(:n0),
1684
+ )) { |*| ([
1685
+ self.to,
1000
1686
  self.__send__(:n1)
1001
- ])}
1002
- ).__send__(
1003
- :/,
1004
- self.r(self.in_arg_normals.__send__(
1687
+ ])})}
1688
+ )
1689
+ declare_meme(
1690
+ :left_chained_operations,
1691
+ [:rule],
1692
+ ::Object::Proc.new { |*| (self.r(self.expr_atom.__send__(
1005
1693
  :[],
1006
1694
  :n0
1007
1695
  ).__send__(
1008
1696
  :+,
1009
- self.arg_sep
1697
+ self.sepd_chained_operation.__send__(:+).__send__(
1698
+ :[],
1699
+ :nlist
1700
+ )
1701
+ )) { |*| (
1702
+ self.nlist.unshift(self.__send__(:n0))
1703
+ self.nlist.__send__(:flatten!)
1704
+ self.collapse(
1705
+ self.nlist,
1706
+ :t_op_exp
1707
+ )
1708
+ self.collapse(
1709
+ self.nlist,
1710
+ :t_op_mult,
1711
+ :t_op_div,
1712
+ :t_op_mod
1713
+ )
1714
+ self.collapse(
1715
+ self.nlist,
1716
+ :t_op_plus,
1717
+ :t_op_minus
1718
+ )
1719
+ self.collapse(
1720
+ self.nlist,
1721
+ :t_op_compare
1722
+ )
1723
+ self.collapse(
1724
+ self.nlist,
1725
+ :t_op_and,
1726
+ :t_op_or,
1727
+ :t_op_and_q,
1728
+ :t_op_or_q,
1729
+ :t_op_void_q
1730
+ ) { |n0, op, n1| (self.ast.branch_op(
1731
+ op,
1732
+ op.sym,
1733
+ n0,
1734
+ n1
1735
+ ))}
1736
+ self.collapse(
1737
+ self.nlist,
1738
+ :t_op_r_pipe
1739
+ ) { |n0, op, n1| (self.ast.pipe_op(
1740
+ op,
1741
+ n0,
1742
+ n1
1743
+ ))}
1744
+ ::Myco.branch_op(:"||", self.nlist.count.__send__(
1745
+ :==,
1746
+ 1
1747
+ )) {self.raise("Failed to fully collapse left_chained_operations: #{self.nlist}")}
1748
+ self.nlist.first
1749
+ )})}
1750
+ )
1751
+ declare_meme(
1752
+ :left_invoke_op,
1753
+ [:rule],
1754
+ ::Object::Proc.new { |*| (::Myco.find_constant(:T).quest.__send__(
1755
+ :/,
1756
+ ::Myco.find_constant(:T).dot
1757
+ ))}
1758
+ )
1759
+ declare_meme(
1760
+ :sepd_chained_invocation,
1761
+ [:rule],
1762
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:C).spc_nl.__send__(:*).__send__(
1763
+ :+,
1764
+ self.left_invoke_op.__send__(
1765
+ :[],
1766
+ :t0
1767
+ )
1010
1768
  ).__send__(
1011
1769
  :+,
1012
- self.in_arg_block.__send__(
1770
+ ::Myco.find_constant(:C).spc_nl.__send__(:*)
1771
+ ).__send__(
1772
+ :+,
1773
+ self.invoke.__send__(
1774
+ :/,
1775
+ self.op_invoke
1776
+ ).__send__(
1013
1777
  :[],
1014
1778
  :n1
1015
1779
  )
1016
- )) { || ([
1017
- *self.__send__(:n0),
1780
+ )) { |*| ([
1781
+ self.__send__(:t0),
1018
1782
  self.__send__(:n1)
1019
- ])}
1020
- ).__send__(
1021
- :/,
1022
- self.r(self.in_arg_kwargs.__send__(
1783
+ ])}.__send__(
1784
+ :/,
1785
+ self.r(::Myco.find_constant(:C).spc.__send__(:*).token(:t_dot).__send__(
1786
+ :[],
1787
+ :t0
1788
+ ).__send__(
1789
+ :+,
1790
+ self.elem_invoke.__send__(
1791
+ :[],
1792
+ :n1
1793
+ )
1794
+ )) { |*| ([
1795
+ self.__send__(:t0),
1796
+ self.__send__(:n1)
1797
+ ])}
1798
+ ))}
1799
+ )
1800
+ declare_meme(
1801
+ :left_chained_invocations,
1802
+ [:rule],
1803
+ ::Object::Proc.new { |*| (self.r(self.expr_atom_not_chained.__send__(
1023
1804
  :[],
1024
1805
  :n0
1025
1806
  ).__send__(
1026
1807
  :+,
1027
- self.arg_sep
1808
+ self.sepd_chained_invocation.__send__(:+).__send__(
1809
+ :[],
1810
+ :nlist
1811
+ )
1812
+ )) { |*| (
1813
+ self.nlist.unshift(self.__send__(:n0))
1814
+ self.nlist.__send__(:flatten!)
1815
+ self.collapse(
1816
+ self.nlist,
1817
+ :t_dot,
1818
+ :t_quest
1819
+ ) { |n0, op, n1| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", op.type.__send__(
1820
+ :==,
1821
+ :t_dot
1822
+ )) {(
1823
+ n1.__send__(
1824
+ :receiver=,
1825
+ n0
1826
+ )
1827
+ n1
1828
+ )}) {self.ast.quest(
1829
+ op,
1830
+ n0,
1831
+ n1
1832
+ )})}
1833
+ ::Myco.branch_op(:"||", self.nlist.count.__send__(
1834
+ :==,
1835
+ 1
1836
+ )) {self.raise("Failed to fully collapse left_chained_invocations: #{self.nlist}")}
1837
+ self.nlist.first
1838
+ )})}
1839
+ )
1840
+ declare_meme(
1841
+ :pipeable,
1842
+ [],
1843
+ ::Object::Proc.new { |*| (self.left_chained_invocations.__send__(
1844
+ :/,
1845
+ self.invoke
1846
+ ))}
1847
+ )
1848
+ declare_meme(
1849
+ :sepd_chained_piping,
1850
+ [:rule],
1851
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:C).spc.__send__(:+).token(:t_op_r_pipe).__send__(
1852
+ :[],
1853
+ :to
1028
1854
  ).__send__(
1029
1855
  :+,
1030
- self.in_arg_block.__send__(
1856
+ self.pipeable.__send__(
1031
1857
  :[],
1032
1858
  :n1
1033
1859
  )
1034
- )) { || ([
1035
- self.__send__(:n0),
1860
+ )) { |*| ([
1861
+ self.to,
1036
1862
  self.__send__(:n1)
1037
- ])}
1038
- ).__send__(
1039
- :/,
1040
- self.r(self.in_arg_normals.__send__(
1863
+ ])})}
1864
+ )
1865
+ declare_meme(
1866
+ :left_chained_piping,
1867
+ [:rule],
1868
+ ::Object::Proc.new { |*| (self.r(self.expr_atom.__send__(
1041
1869
  :[],
1042
1870
  :n0
1043
- )) { || ([*self.__send__(:n0)])}
1044
- ).__send__(
1045
- :/,
1046
- self.r(self.in_arg_kwargs.__send__(
1047
- :[],
1048
- :n0
1049
- )) { || ([self.__send__(:n0)])}
1050
- ).__send__(
1051
- :/,
1052
- self.r(self.in_arg_block.__send__(
1053
- :[],
1054
- :n0
1055
- )) { || ([self.__send__(:n0)])}
1056
- ))}
1057
- declare_meme(:arg_list, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).args_begin.__send__(
1058
- :[],
1059
- :tb
1060
- ).__send__(
1061
- :+,
1062
- self.arg_sep_opt
1063
- ).__send__(
1064
- :+,
1065
- self.in_arg_list.__send__(:-).__send__(
1066
- :[],
1067
- :nlist
1068
- )
1069
- ).__send__(
1070
- :+,
1071
- self.arg_sep_opt
1072
- ).__send__(
1073
- :+,
1074
- ::Myco.find_constant(:T).args_end
1075
- )) { || (self.ast.args(
1076
- self.tb,
1077
- ::Myco.branch_op(:"||", self.nlist) {[]}
1078
- ))})}
1079
- declare_meme(:lit_array, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).array_begin.__send__(
1080
- :[],
1081
- :tb
1082
- ).__send__(
1083
- :+,
1084
- self.arg_sep_opt
1085
- ).__send__(
1086
- :+,
1087
- self.in_arg_list.__send__(:-).__send__(
1088
- :[],
1089
- :nlist
1090
- )
1091
- ).__send__(
1092
- :+,
1093
- self.arg_sep_opt
1094
- ).__send__(
1095
- :+,
1096
- ::Myco.find_constant(:T).array_end
1097
- )) { || (self.ast.array(
1098
- self.tb,
1099
- ::Myco.branch_op(:"||", self.nlist) {[]}
1100
- ))})}
1101
- declare_meme(:param_sep, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:C).spc.__send__(:*).__send__(
1102
- :+,
1103
- ::Myco.find_constant(:T).arg_sep
1104
- ).__send__(
1105
- :+,
1106
- ::Myco.find_constant(:C).spc.__send__(:*)
1107
- ).__send__(:+).__send__(
1108
- :/,
1109
- ::Myco.find_constant(:C).spc.__send__(:*).__send__(
1110
- :+,
1111
- ::Myco.find_constant(:T).params_end.__send__(:!).__send__(:!)
1112
- )
1113
- ))}
1114
- declare_meme(:param_sep_opt, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:C).spc.__send__(
1115
- :/,
1116
- ::Myco.find_constant(:T).arg_sep
1117
- ).__send__(:*))}
1118
- declare_meme(:param_sepd, [], nil, ::Myco.cscope.dup) { |x| (self.r(x.__send__(
1119
- :[],
1120
- :n0
1121
- ).__send__(
1122
- :+,
1123
- self.param_sep
1124
- )) { || (self.__send__(:n0))})}
1125
- declare_meme(:req_param, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).identifier.__send__(
1126
- :[],
1127
- :ti
1128
- ).__send__(
1129
- :+,
1130
- self.param_sep.__send__(:!).__send__(:!)
1131
- )) { || (self.ast.reqprm(
1132
- self.ti,
1133
- self.ti.sym
1134
- ))})}
1135
- declare_meme(:opt_param, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).identifier.__send__(
1136
- :[],
1137
- :ti
1138
- ).__send__(
1139
- :+,
1140
- ::Myco.find_constant(:C).spc_nl.__send__(:*)
1141
- ).__send__(
1142
- :+,
1143
- ::Myco.find_constant(:T).assign.__send__(
1144
- :[],
1145
- :to
1146
- )
1147
- ).__send__(
1148
- :+,
1149
- ::Myco.find_constant(:C).spc_nl.__send__(:*)
1150
- ).__send__(
1151
- :+,
1152
- self.arg_expr.__send__(
1153
- :[],
1154
- :nv
1155
- )
1156
- )) { || (self.ast.optprm(
1157
- self.ti,
1158
- self.ti.sym,
1159
- self.nv
1160
- ))})}
1161
- declare_meme(:rest_param, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).op_mult.__send__(
1162
- :+,
1163
- ::Myco.find_constant(:C).spc_nl.__send__(:*)
1164
- ).__send__(
1165
- :+,
1166
- ::Myco.find_constant(:T).identifier.__send__(
1167
- :[],
1168
- :ti
1169
- )
1170
- )) { || (self.ast.restprm(
1171
- self.ti,
1172
- self.ti.sym
1173
- ))})}
1174
- declare_meme(:kwopt_param, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).identifier.__send__(
1175
- :[],
1176
- :ti
1177
- ).__send__(
1178
- :+,
1179
- ::Myco.find_constant(:C).spc_nl.__send__(:*)
1180
- ).__send__(
1181
- :+,
1182
- ::Myco.find_constant(:T).meme_mark.__send__(
1183
- :[],
1184
- :to
1185
- )
1186
- ).__send__(
1187
- :+,
1188
- ::Myco.find_constant(:C).spc_nl.__send__(:*)
1189
- ).__send__(
1190
- :+,
1191
- self.arg_expr.__send__(
1192
- :[],
1193
- :nv
1194
- )
1195
- )) { || (self.ast.kwoptprm(
1196
- self.ti,
1197
- self.ti.sym,
1198
- self.nv
1199
- ))})}
1200
- declare_meme(:kwreq_param, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).identifier.__send__(
1201
- :[],
1202
- :ti
1203
- ).__send__(
1204
- :+,
1205
- ::Myco.find_constant(:C).spc_nl.__send__(:*)
1206
- ).__send__(
1207
- :+,
1208
- ::Myco.find_constant(:T).meme_mark.__send__(
1209
- :[],
1210
- :to
1211
- )
1212
- ).__send__(
1213
- :+,
1214
- self.param_sep.__send__(:!).__send__(:!)
1215
- )) { || (self.ast.kwreqprm(
1216
- self.ti,
1217
- self.ti.sym
1218
- ))})}
1219
- declare_meme(:kwrest_param, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).op_exp.__send__(
1220
- :+,
1221
- ::Myco.find_constant(:C).spc_nl.__send__(:*)
1222
- ).__send__(
1223
- :+,
1224
- ::Myco.find_constant(:T).identifier.__send__(
1225
- :[],
1226
- :ti
1227
- )
1228
- )) { || (self.ast.kwrestprm(
1229
- self.ti,
1230
- self.ti.sym
1231
- ))})}
1232
- declare_meme(:block_param, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).op_toproc.__send__(
1233
- :+,
1234
- ::Myco.find_constant(:C).spc_nl.__send__(:*)
1235
- ).__send__(
1236
- :+,
1237
- ::Myco.find_constant(:T).identifier.__send__(
1238
- :[],
1239
- :ti
1240
- )
1241
- )) { || (self.ast.blkprm(
1242
- self.ti,
1243
- self.ti.sym
1244
- ))})}
1245
- declare_meme(:param_list, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).params_begin.__send__(
1246
- :[],
1247
- :tb
1248
- ).__send__(
1249
- :+,
1250
- self.param_sep_opt
1251
- ).__send__(
1252
- :+,
1253
- self.param_sepd(self.req_param).__send__(:*).__send__(
1254
- :[],
1255
- :required
1256
- )
1257
- ).__send__(
1258
- :+,
1259
- self.param_sepd(self.opt_param).__send__(:*).__send__(
1260
- :[],
1261
- :optional
1262
- )
1263
- ).__send__(
1264
- :+,
1265
- self.param_sepd(self.rest_param).__send__(:-).__send__(
1266
- :[],
1267
- :rest
1268
- )
1269
- ).__send__(
1270
- :+,
1271
- self.param_sepd(self.req_param).__send__(:*).__send__(
1272
- :[],
1273
- :post
1274
- )
1275
- ).__send__(
1276
- :+,
1277
- self.param_sepd(self.kwreq_param.__send__(
1278
- :/,
1279
- self.kwopt_param
1280
- )).__send__(:*).__send__(
1281
- :[],
1282
- :kw
1283
- )
1284
- ).__send__(
1285
- :+,
1286
- self.param_sepd(self.kwrest_param).__send__(:-).__send__(
1287
- :[],
1288
- :kwrest
1289
- )
1290
- ).__send__(
1291
- :+,
1292
- self.param_sepd(self.block_param).__send__(:-).__send__(
1293
- :[],
1294
- :block
1295
- )
1296
- ).__send__(
1297
- :+,
1298
- ::Myco.find_constant(:T).params_end
1299
- )) { || (
1300
- kwrequired = self.kw.select { |x| (x.node_type.__send__(
1301
- :==,
1302
- :kwreqprm
1303
- ))}
1304
- kwoptional = self.kw.select { |x| (x.node_type.__send__(
1305
- :==,
1306
- :kwoptprm
1307
- ))}
1308
- self.ast.params(
1309
- self.tb,
1310
- self.required,
1311
- self.optional,
1312
- ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.rest.__send__(
1313
- :is_a?,
1314
- ::Myco.find_constant(:Array)
1315
- )) {self.rest.first}) {self.rest},
1316
- self.post,
1317
- kwrequired,
1318
- kwoptional,
1319
- ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.kwrest.__send__(
1320
- :is_a?,
1321
- ::Myco.find_constant(:Array)
1322
- )) {self.kwrest.first}) {self.kwrest},
1323
- ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.block.__send__(
1324
- :is_a?,
1325
- ::Myco.find_constant(:Array)
1326
- )) {self.block.first}) {self.block}
1327
- )
1328
- )})}
1329
- declare_meme(:left_op_normal, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:T).op_exp.__send__(
1330
- :/,
1331
- ::Myco.find_constant(:T).op_mult
1332
- ).__send__(
1333
- :/,
1334
- ::Myco.find_constant(:T).op_div
1335
- ).__send__(
1336
- :/,
1337
- ::Myco.find_constant(:T).op_mod
1338
- ).__send__(
1339
- :/,
1340
- ::Myco.find_constant(:T).op_plus
1341
- ).__send__(
1342
- :/,
1343
- ::Myco.find_constant(:T).op_minus
1344
- ).__send__(
1345
- :/,
1346
- ::Myco.find_constant(:T).op_compare
1347
- ).__send__(
1348
- :/,
1349
- ::Myco.find_constant(:T).op_r_pipe
1350
- ))}
1351
- declare_meme(:left_op_branch, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:T).op_and.__send__(
1352
- :/,
1353
- ::Myco.find_constant(:T).op_or
1354
- ).__send__(
1355
- :/,
1356
- ::Myco.find_constant(:T).op_and_q
1357
- ).__send__(
1358
- :/,
1359
- ::Myco.find_constant(:T).op_or_q
1360
- ).__send__(
1361
- :/,
1362
- ::Myco.find_constant(:T).op_void_q
1363
- ))}
1364
- declare_meme(:left_op, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.left_op_normal.__send__(
1365
- :/,
1366
- self.left_op_branch
1367
- ))}
1368
- declare_meme(:sepd_chained_operation, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:C).spc_nl.__send__(:*).__send__(
1369
- :+,
1370
- self.left_op.__send__(
1871
+ ).__send__(
1872
+ :+,
1873
+ self.sepd_chained_piping.__send__(:+).__send__(
1874
+ :[],
1875
+ :nlist
1876
+ )
1877
+ )) { |*| (
1878
+ self.nlist.unshift(self.__send__(:n0))
1879
+ self.nlist.__send__(:flatten!)
1880
+ self.collapse(
1881
+ self.nlist,
1882
+ :t_op_r_pipe
1883
+ ) { |n0, op, n1| (self.ast.pipe_op(
1884
+ op,
1885
+ n0,
1886
+ n1
1887
+ ))}
1888
+ ::Myco.branch_op(:"||", self.nlist.count.__send__(
1889
+ :==,
1890
+ 1
1891
+ )) {self.raise("Failed to fully collapse left_chained_piping: #{self.nlist}")}
1892
+ self.nlist.first
1893
+ )})}
1894
+ )
1895
+ declare_meme(
1896
+ :unary_operation,
1897
+ [:rule],
1898
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).op_not.__send__(
1371
1899
  :[],
1372
1900
  :to
1373
- )
1374
- ).__send__(
1375
- :+,
1376
- ::Myco.find_constant(:C).spc_nl.__send__(:*)
1377
- ).__send__(
1378
- :+,
1379
- self.expr_atom.__send__(
1380
- :[],
1381
- :n1
1382
- )
1383
- )) { || ([
1384
- self.to,
1385
- self.__send__(:n1)
1386
- ])})}
1387
- declare_meme(:left_chained_operations, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.expr_atom.__send__(
1388
- :[],
1389
- :n0
1390
- ).__send__(
1391
- :+,
1392
- self.sepd_chained_operation.__send__(:+).__send__(
1393
- :[],
1394
- :nlist
1395
- )
1396
- )) { || (
1397
- self.nlist.unshift(self.__send__(:n0))
1398
- self.nlist.__send__(:flatten!)
1399
- self.collapse(
1400
- self.nlist,
1401
- :t_op_exp
1402
- )
1403
- self.collapse(
1404
- self.nlist,
1405
- :t_op_mult,
1406
- :t_op_div,
1407
- :t_op_mod
1408
- )
1409
- self.collapse(
1410
- self.nlist,
1411
- :t_op_plus,
1412
- :t_op_minus
1413
- )
1414
- self.collapse(
1415
- self.nlist,
1416
- :t_op_compare
1417
- )
1418
- self.collapse(
1419
- self.nlist,
1420
- :t_op_and,
1421
- :t_op_or,
1422
- :t_op_and_q,
1423
- :t_op_or_q,
1424
- :t_op_void_q
1425
- ) { |n0, op, n1| (self.ast.branch_op(
1426
- op,
1427
- op.sym,
1428
- n0,
1429
- n1
1430
- ))}
1431
- self.collapse(
1432
- self.nlist,
1433
- :t_op_r_pipe
1434
- ) { |n0, op, n1| (self.ast.pipe_op(
1435
- op,
1436
- n0,
1437
- n1
1901
+ ).__send__(
1902
+ :+,
1903
+ self.expr_atom.__send__(
1904
+ :[],
1905
+ :n0
1906
+ )
1907
+ )) { |*| (self.ast.invoke(
1908
+ self.to,
1909
+ self.__send__(:n0),
1910
+ :!,
1911
+ nil
1912
+ ))})}
1913
+ )
1914
+ declare_meme(
1915
+ :t_inln_sep,
1916
+ [:rule],
1917
+ ::Object::Proc.new { |*| (::Myco.find_constant(:T).arg_sep.inner.__send__(:!).__send__(
1918
+ :+,
1919
+ ::Myco.find_constant(:T).expr_sep
1438
1920
  ))}
1439
- ::Myco.branch_op(:"||", self.nlist.count.__send__(
1440
- :==,
1441
- 1
1442
- )) {self.raise("Failed to fully collapse left_chained_operations: #{self.nlist}")}
1443
- self.nlist.first
1444
- )})}
1445
- declare_meme(:left_invoke_op, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:T).quest.__send__(
1446
- :/,
1447
- ::Myco.find_constant(:T).dot
1448
- ))}
1449
- declare_meme(:sepd_chained_invocation, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:C).spc_nl.__send__(:*).__send__(
1450
- :+,
1451
- self.left_invoke_op.__send__(
1452
- :[],
1453
- :t0
1454
- )
1455
- ).__send__(
1456
- :+,
1457
- ::Myco.find_constant(:C).spc_nl.__send__(:*)
1458
- ).__send__(
1459
- :+,
1460
- self.invoke.__send__(
1921
+ )
1922
+ declare_meme(
1923
+ :inln_sep,
1924
+ [:rule],
1925
+ ::Object::Proc.new { |*| (::Myco.find_constant(:C).spc.__send__(:*).__send__(
1926
+ :+,
1927
+ self.t_inln_sep
1928
+ ).__send__(
1929
+ :+,
1930
+ ::Myco.find_constant(:C).spc.__send__(:*)
1931
+ ).__send__(:+))}
1932
+ )
1933
+ declare_meme(
1934
+ :inln_sep_opt,
1935
+ [:rule],
1936
+ ::Object::Proc.new { |*| (::Myco.find_constant(:C).spc.__send__(
1461
1937
  :/,
1462
- self.op_invoke
1938
+ self.t_inln_sep
1939
+ ).__send__(:*))}
1940
+ )
1941
+ declare_meme(
1942
+ :expr_sep,
1943
+ [:rule],
1944
+ ::Object::Proc.new { |*| (::Myco.find_constant(:C).spc.__send__(:*).__send__(
1945
+ :+,
1946
+ ::Myco.find_constant(:T).expr_sep
1463
1947
  ).__send__(
1948
+ :+,
1949
+ ::Myco.find_constant(:C).spc.__send__(:*)
1950
+ ).__send__(:+))}
1951
+ )
1952
+ declare_meme(
1953
+ :expr_sep_opt,
1954
+ [:rule],
1955
+ ::Object::Proc.new { |*| (::Myco.find_constant(:C).spc.__send__(
1956
+ :/,
1957
+ ::Myco.find_constant(:T).expr_sep
1958
+ ).__send__(:*))}
1959
+ )
1960
+ declare_meme(
1961
+ :meme_inline_sepd_expr,
1962
+ [:rule],
1963
+ ::Object::Proc.new { |*| (self.r(self.inln_sep.__send__(
1964
+ :+,
1965
+ self.meme_expr.__send__(
1966
+ :[],
1967
+ :n
1968
+ )
1969
+ )) { |*| (self.n)})}
1970
+ )
1971
+ declare_meme(
1972
+ :meme_inline_sepd_exprs,
1973
+ [:rule],
1974
+ ::Object::Proc.new { |*| (self.r(self.meme_expr.__send__(
1464
1975
  :[],
1465
- :n1
1466
- )
1467
- )) { || ([
1468
- self.__send__(:t0),
1469
- self.__send__(:n1)
1470
- ])}.__send__(
1471
- :/,
1472
- self.r(::Myco.find_constant(:C).spc.__send__(:*).token(:t_dot).__send__(
1473
- :[],
1474
- :t0
1976
+ :n0
1475
1977
  ).__send__(
1476
1978
  :+,
1477
- self.elem_invoke.__send__(
1979
+ self.meme_inline_sepd_expr.__send__(:*).__send__(
1478
1980
  :[],
1479
- :n1
1981
+ :nrest
1480
1982
  )
1481
- )) { || ([
1482
- self.__send__(:t0),
1483
- self.__send__(:n1)
1484
- ])}
1485
- ))}
1486
- declare_meme(:left_chained_invocations, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.expr_atom_not_chained.__send__(
1487
- :[],
1488
- :n0
1489
- ).__send__(
1490
- :+,
1491
- self.sepd_chained_invocation.__send__(:+).__send__(
1492
- :[],
1493
- :nlist
1494
- )
1495
- )) { || (
1496
- self.nlist.unshift(self.__send__(:n0))
1497
- self.nlist.__send__(:flatten!)
1498
- self.collapse(
1499
- self.nlist,
1500
- :t_dot,
1501
- :t_quest
1502
- ) { |n0, op, n1| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", op.type.__send__(
1503
- :==,
1504
- :t_dot
1505
- )) {(
1506
- n1.__send__(
1507
- :receiver=,
1508
- n0
1509
- )
1510
- n1
1511
- )}) {self.ast.quest(
1512
- op,
1513
- n0,
1514
- n1
1515
- )})}
1516
- ::Myco.branch_op(:"||", self.nlist.count.__send__(
1517
- :==,
1518
- 1
1519
- )) {self.raise("Failed to fully collapse left_chained_invocations: #{self.nlist}")}
1520
- self.nlist.first
1521
- )})}
1522
- declare_meme(:pipeable, [], nil, ::Myco.cscope.dup) { |*| (self.left_chained_invocations.__send__(
1523
- :/,
1524
- self.invoke
1525
- ))}
1526
- declare_meme(:sepd_chained_piping, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:C).spc.__send__(:+).token(:t_op_r_pipe).__send__(
1527
- :[],
1528
- :to
1529
- ).__send__(
1530
- :+,
1531
- self.pipeable.__send__(
1532
- :[],
1533
- :n1
1534
- )
1535
- )) { || ([
1536
- self.to,
1537
- self.__send__(:n1)
1538
- ])})}
1539
- declare_meme(:left_chained_piping, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.expr_atom.__send__(
1540
- :[],
1541
- :n0
1542
- ).__send__(
1543
- :+,
1544
- self.sepd_chained_piping.__send__(:+).__send__(
1545
- :[],
1546
- :nlist
1547
- )
1548
- )) { || (
1549
- self.nlist.unshift(self.__send__(:n0))
1550
- self.nlist.__send__(:flatten!)
1551
- self.collapse(
1552
- self.nlist,
1553
- :t_op_r_pipe
1554
- ) { |n0, op, n1| (self.ast.pipe_op(
1555
- op,
1556
- n0,
1557
- n1
1558
- ))}
1559
- ::Myco.branch_op(:"||", self.nlist.count.__send__(
1560
- :==,
1561
- 1
1562
- )) {self.raise("Failed to fully collapse left_chained_piping: #{self.nlist}")}
1563
- self.nlist.first
1564
- )})}
1565
- declare_meme(:unary_operation, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).op_not.__send__(
1566
- :[],
1567
- :to
1568
- ).__send__(
1569
- :+,
1570
- self.expr_atom.__send__(
1983
+ ).__send__(
1984
+ :+,
1985
+ self.inln_sep_opt
1986
+ )) { |*| ([
1987
+ self.__send__(:n0),
1988
+ *self.nrest
1989
+ ])})}
1990
+ )
1991
+ declare_meme(
1992
+ :meme_sepd_expr,
1993
+ [:rule],
1994
+ ::Object::Proc.new { |*| (self.r(self.expr_sep.__send__(
1995
+ :+,
1996
+ self.meme_expr.__send__(
1997
+ :[],
1998
+ :n
1999
+ )
2000
+ )) { |*| (self.n)})}
2001
+ )
2002
+ declare_meme(
2003
+ :meme_sepd_exprs,
2004
+ [:rule],
2005
+ ::Object::Proc.new { |*| (self.r(self.meme_expr.__send__(
1571
2006
  :[],
1572
2007
  :n0
1573
- )
1574
- )) { || (self.ast.invoke(
1575
- self.to,
1576
- self.__send__(:n0),
1577
- :!,
1578
- nil
1579
- ))})}
1580
- declare_meme(:t_inln_sep, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:T).arg_sep.inner.__send__(:!).__send__(
1581
- :+,
1582
- ::Myco.find_constant(:T).expr_sep
1583
- ))}
1584
- declare_meme(:inln_sep, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:C).spc.__send__(:*).__send__(
1585
- :+,
1586
- self.t_inln_sep
1587
- ).__send__(
1588
- :+,
1589
- ::Myco.find_constant(:C).spc.__send__(:*)
1590
- ).__send__(:+))}
1591
- declare_meme(:inln_sep_opt, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:C).spc.__send__(
1592
- :/,
1593
- self.t_inln_sep
1594
- ).__send__(:*))}
1595
- declare_meme(:expr_sep, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:C).spc.__send__(:*).__send__(
1596
- :+,
1597
- ::Myco.find_constant(:T).expr_sep
1598
- ).__send__(
1599
- :+,
1600
- ::Myco.find_constant(:C).spc.__send__(:*)
1601
- ).__send__(:+))}
1602
- declare_meme(:expr_sep_opt, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:C).spc.__send__(
1603
- :/,
1604
- ::Myco.find_constant(:T).expr_sep
1605
- ).__send__(:*))}
1606
- declare_meme(:meme_inline_sepd_expr, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.inln_sep.__send__(
1607
- :+,
1608
- self.meme_expr.__send__(
1609
- :[],
1610
- :n
1611
- )
1612
- )) { || (self.n)})}
1613
- declare_meme(:meme_inline_sepd_exprs, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.meme_expr.__send__(
1614
- :[],
1615
- :n0
1616
- ).__send__(
1617
- :+,
1618
- self.meme_inline_sepd_expr.__send__(:*).__send__(
1619
- :[],
1620
- :nrest
1621
- )
1622
- ).__send__(
1623
- :+,
1624
- self.inln_sep_opt
1625
- )) { || ([
1626
- self.__send__(:n0),
1627
- *self.nrest
1628
- ])})}
1629
- declare_meme(:meme_sepd_expr, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.expr_sep.__send__(
1630
- :+,
1631
- self.meme_expr.__send__(
1632
- :[],
1633
- :n
1634
- )
1635
- )) { || (self.n)})}
1636
- declare_meme(:meme_sepd_exprs, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.meme_expr.__send__(
1637
- :[],
1638
- :n0
1639
- ).__send__(
1640
- :+,
1641
- self.meme_sepd_expr.__send__(:*).__send__(
1642
- :[],
1643
- :nrest
1644
- )
1645
- ).__send__(
1646
- :+,
1647
- self.expr_sep_opt
1648
- )) { || ([
1649
- self.__send__(:n0),
1650
- *self.nrest
1651
- ])})}
1652
- declare_meme(:meme_inline_expr_body, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.inln_sep_opt.__send__(
1653
- :+,
1654
- self.meme_inline_sepd_exprs.__send__(
1655
- :[],
1656
- :nlist
1657
- )
1658
- )) { || (self.ast.sequence(
1659
- self.nlist.first,
1660
- self.nlist
1661
- ))})}
1662
- declare_meme(:meme_expr_body, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.expr_sep_opt.__send__(
1663
- :+,
1664
- self.meme_sepd_exprs.__send__(
1665
- :[],
1666
- :nlist
1667
- )
1668
- ).__send__(
1669
- :+,
1670
- ::Myco.find_constant(:T).meme_end.__send__(
1671
- :[],
1672
- :te
1673
- )
1674
- )) { || (self.ast.sequence(
1675
- self.nlist.first,
1676
- self.nlist
1677
- ))}.__send__(
1678
- :/,
1679
- self.r(self.expr_sep_opt.__send__(
2008
+ ).__send__(
2009
+ :+,
2010
+ self.meme_sepd_expr.__send__(:*).__send__(
2011
+ :[],
2012
+ :nrest
2013
+ )
2014
+ ).__send__(
2015
+ :+,
2016
+ self.expr_sep_opt
2017
+ )) { |*| ([
2018
+ self.__send__(:n0),
2019
+ *self.nrest
2020
+ ])})}
2021
+ )
2022
+ declare_meme(
2023
+ :meme_inline_expr_body,
2024
+ [:rule],
2025
+ ::Object::Proc.new { |*| (self.r(self.inln_sep_opt.__send__(
2026
+ :+,
2027
+ self.meme_inline_sepd_exprs.__send__(
2028
+ :[],
2029
+ :nlist
2030
+ )
2031
+ )) { |*| (self.ast.sequence(
2032
+ self.nlist.first,
2033
+ self.nlist
2034
+ ))})}
2035
+ )
2036
+ declare_meme(
2037
+ :meme_expr_body,
2038
+ [:rule],
2039
+ ::Object::Proc.new { |*| (self.r(self.expr_sep_opt.__send__(
2040
+ :+,
2041
+ self.meme_sepd_exprs.__send__(
2042
+ :[],
2043
+ :nlist
2044
+ )
2045
+ ).__send__(
1680
2046
  :+,
1681
2047
  ::Myco.find_constant(:T).meme_end.__send__(
1682
2048
  :[],
1683
2049
  :te
1684
2050
  )
1685
- )) { || (self.ast.null(self.te))}
1686
- ))}
1687
- declare_meme(:paren_expr_body, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.expr_sep_opt.__send__(
1688
- :+,
1689
- self.meme_sepd_exprs.__send__(
1690
- :[],
1691
- :nlist
1692
- )
1693
- ).__send__(
1694
- :+,
1695
- ::Myco.find_constant(:T).paren_end.__send__(
1696
- :[],
1697
- :te
1698
- )
1699
- )) { || (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.nlist.count.__send__(
1700
- :==,
1701
- 1
1702
- )) {self.nlist.first}) {self.ast.sequence(
1703
- self.nlist.first,
1704
- self.nlist
1705
- )})}.__send__(
1706
- :/,
1707
- self.r(self.expr_sep_opt.__send__(
2051
+ )) { |*| (self.ast.sequence(
2052
+ self.nlist.first,
2053
+ self.nlist
2054
+ ))}.__send__(
2055
+ :/,
2056
+ self.r(self.expr_sep_opt.__send__(
2057
+ :+,
2058
+ ::Myco.find_constant(:T).meme_end.__send__(
2059
+ :[],
2060
+ :te
2061
+ )
2062
+ )) { |*| (self.ast.null(self.te))}
2063
+ ))}
2064
+ )
2065
+ declare_meme(
2066
+ :paren_expr_body,
2067
+ [:rule],
2068
+ ::Object::Proc.new { |*| (self.r(self.expr_sep_opt.__send__(
2069
+ :+,
2070
+ self.meme_sepd_exprs.__send__(
2071
+ :[],
2072
+ :nlist
2073
+ )
2074
+ ).__send__(
1708
2075
  :+,
1709
2076
  ::Myco.find_constant(:T).paren_end.__send__(
1710
2077
  :[],
1711
2078
  :te
1712
2079
  )
1713
- )) { || (self.ast.null(self.te))}
1714
- ))}
1715
- declare_meme(:paren_expr, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).paren_begin.__send__(
1716
- :+,
1717
- self.paren_expr_body.__send__(
1718
- :[],
1719
- :n0
1720
- )
1721
- )) { || (self.__send__(:n0))})}
1722
- declare_meme(:meme_enclosed_expr_body, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).meme_begin.__send__(
1723
- :+,
1724
- self.meme_expr_body.__send__(
2080
+ )) { |*| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.nlist.count.__send__(
2081
+ :==,
2082
+ 1
2083
+ )) {self.nlist.first}) {self.ast.sequence(
2084
+ self.nlist.first,
2085
+ self.nlist
2086
+ )})}.__send__(
2087
+ :/,
2088
+ self.r(self.expr_sep_opt.__send__(
2089
+ :+,
2090
+ ::Myco.find_constant(:T).paren_end.__send__(
2091
+ :[],
2092
+ :te
2093
+ )
2094
+ )) { |*| (self.ast.null(self.te))}
2095
+ ))}
2096
+ )
2097
+ declare_meme(
2098
+ :paren_expr,
2099
+ [:rule],
2100
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).paren_begin.__send__(
2101
+ :+,
2102
+ self.paren_expr_body.__send__(
2103
+ :[],
2104
+ :n0
2105
+ )
2106
+ )) { |*| (self.__send__(:n0))})}
2107
+ )
2108
+ declare_meme(
2109
+ :meme_enclosed_expr_body,
2110
+ [:rule],
2111
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:T).meme_begin.__send__(
2112
+ :+,
2113
+ self.meme_expr_body.__send__(
2114
+ :[],
2115
+ :n0
2116
+ )
2117
+ )) { |*| (self.__send__(:n0))})}
2118
+ )
2119
+ declare_meme(
2120
+ :meme_either_body_as_block,
2121
+ [:rule],
2122
+ ::Object::Proc.new { |*| (self.r(self.block_body.__send__(
2123
+ :/,
2124
+ self.open_block_body
2125
+ ).__send__(
1725
2126
  :[],
1726
2127
  :n0
1727
- )
1728
- )) { || (self.__send__(:n0))})}
1729
- declare_meme(:meme_either_body_as_block, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.block_body.__send__(
1730
- :/,
1731
- self.open_block_body
1732
- ).__send__(
1733
- :[],
1734
- :n0
1735
- )) { || (self.ast.blklit(
1736
- self.__send__(:n0),
1737
- self.__send__(:n0)
1738
- ))})}
1739
- declare_meme(:decoration, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.invoke_classic_form.__send__(
1740
- :/,
1741
- self.id_as_symbol
1742
- ).__send__(
1743
- :/,
1744
- self.lit_string_as_symbol
1745
- ).__send__(
1746
- :/,
1747
- self.constant
1748
- ))}
1749
- declare_meme(:sepd_decoration, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:C).spc.__send__(:*).__send__(
1750
- :+,
1751
- self.decoration.__send__(
1752
- :[],
1753
- :n
1754
- )
1755
- )) { || (self.n)})}
1756
- declare_meme(:sepd_decorations, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.decoration.__send__(
1757
- :[],
1758
- :n0
1759
- ).__send__(
1760
- :+,
1761
- self.sepd_decoration.__send__(:*).__send__(
1762
- :[],
1763
- :nrest
1764
- )
1765
- )) { || ([
1766
- self.__send__(:n0),
1767
- *self.nrest
1768
- ])})}
1769
- declare_meme(:meme, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.decorators_and_meme_name.__send__(
1770
- :[],
1771
- :nd
1772
- ).__send__(
1773
- :+,
1774
- ::Myco.find_constant(:C).spc.__send__(:*)
1775
- ).__send__(
1776
- :+,
1777
- ::Myco.find_constant(:T).meme_mark.__send__(
1778
- :[],
1779
- :tm
1780
- )
1781
- ).__send__(
1782
- :+,
1783
- self.r(::Myco.find_constant(:C).spc_nl.__send__(:*).__send__(
2128
+ )) { |*| (self.ast.blklit(
2129
+ self.__send__(:n0),
2130
+ self.__send__(:n0)
2131
+ ))})}
2132
+ )
2133
+ declare_meme(
2134
+ :decoration,
2135
+ [:rule],
2136
+ ::Object::Proc.new { |*| (self.invoke_classic_form.__send__(
2137
+ :/,
2138
+ self.id_as_symbol
2139
+ ).__send__(
2140
+ :/,
2141
+ self.lit_string_as_symbol
2142
+ ).__send__(
2143
+ :/,
2144
+ self.constant
2145
+ ))}
2146
+ )
2147
+ declare_meme(
2148
+ :sepd_decoration,
2149
+ [:rule],
2150
+ ::Object::Proc.new { |*| (self.r(::Myco.find_constant(:C).spc.__send__(:*).__send__(
1784
2151
  :+,
1785
- self.param_list.__send__(:-).__send__(
2152
+ self.decoration.__send__(
1786
2153
  :[],
1787
2154
  :n
1788
2155
  )
1789
- )) { || (self.n)}.__send__(
2156
+ )) { |*| (self.n)})}
2157
+ )
2158
+ declare_meme(
2159
+ :sepd_decorations,
2160
+ [:rule],
2161
+ ::Object::Proc.new { |*| (self.r(self.decoration.__send__(
1790
2162
  :[],
1791
- :np
1792
- )
1793
- ).__send__(
1794
- :+,
1795
- ::Myco.find_constant(:C).spc_nl.__send__(:*)
1796
- ).__send__(
1797
- :+,
1798
- self.meme_either_body.__send__(
1799
- :[],
1800
- :nb
1801
- )
1802
- )) { || (self.ast.meme(
1803
- self.tm,
1804
- self.nd.body.shift.name,
1805
- self.nd,
1806
- self.np,
1807
- self.nb
1808
- ))}.__send__(
1809
- :/,
1810
- self.r(self.decorators_and_meme_name.__send__(
2163
+ :n0
2164
+ ).__send__(
2165
+ :+,
2166
+ self.sepd_decoration.__send__(:*).__send__(
2167
+ :[],
2168
+ :nrest
2169
+ )
2170
+ )) { |*| ([
2171
+ self.__send__(:n0),
2172
+ *self.nrest
2173
+ ])})}
2174
+ )
2175
+ declare_meme(
2176
+ :meme,
2177
+ [:rule],
2178
+ ::Object::Proc.new { |*| (self.r(self.decorators_and_meme_name.__send__(
1811
2179
  :[],
1812
2180
  :nd
1813
- )) { || (self.ast.meme(
1814
- self.nd,
2181
+ ).__send__(
2182
+ :+,
2183
+ ::Myco.find_constant(:C).spc.__send__(:*)
2184
+ ).__send__(
2185
+ :+,
2186
+ ::Myco.find_constant(:T).meme_mark.__send__(
2187
+ :[],
2188
+ :tm
2189
+ )
2190
+ ).__send__(
2191
+ :+,
2192
+ self.r(::Myco.find_constant(:C).spc_nl.__send__(:*).__send__(
2193
+ :+,
2194
+ self.param_list.__send__(:-).__send__(
2195
+ :[],
2196
+ :n
2197
+ )
2198
+ )) { |*| (self.n)}.__send__(
2199
+ :[],
2200
+ :np
2201
+ )
2202
+ ).__send__(
2203
+ :+,
2204
+ ::Myco.find_constant(:C).spc_nl.__send__(:*)
2205
+ ).__send__(
2206
+ :+,
2207
+ self.meme_either_body.__send__(
2208
+ :[],
2209
+ :nb
2210
+ )
2211
+ )) { |*| (self.ast.meme(
2212
+ self.tm,
1815
2213
  self.nd.body.shift.name,
1816
2214
  self.nd,
1817
- nil,
1818
- nil
2215
+ self.np,
2216
+ self.nb
2217
+ ))}.__send__(
2218
+ :/,
2219
+ self.r(self.decorators_and_meme_name.__send__(
2220
+ :[],
2221
+ :nd
2222
+ )) { |*| (self.ast.meme(
2223
+ self.nd,
2224
+ self.nd.body.shift.name,
2225
+ self.nd,
2226
+ nil,
2227
+ nil
2228
+ ))}
1819
2229
  ))}
1820
- ))}
1821
- declare_meme(:meme, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.sepd_decorations.__send__(
1822
- :[],
1823
- :nlist
1824
- ).__send__(
1825
- :+,
1826
- ::Myco.find_constant(:C).spc.__send__(:*)
1827
- ).__send__(
1828
- :+,
1829
- ::Myco.find_constant(:T).meme_mark.__send__(
1830
- :[],
1831
- :tm
1832
- )
1833
- ).__send__(
1834
- :+,
1835
- ::Myco.find_constant(:C).spc_nl.__send__(:*)
1836
- ).__send__(
1837
- :+,
1838
- self.meme_either_body_as_block.__send__(
1839
- :[],
1840
- :nb
1841
- )
1842
- )) { || (self.ast.meme(
1843
- self.nlist.first,
1844
- self.nlist,
1845
- self.nb
1846
- ))}.__send__(
1847
- :/,
1848
- self.r(self.sepd_decorations.__send__(
2230
+ )
2231
+ declare_meme(
2232
+ :meme,
2233
+ [:rule],
2234
+ ::Object::Proc.new { |*| (self.r(self.sepd_decorations.__send__(
1849
2235
  :[],
1850
2236
  :nlist
1851
- )) { || (self.ast.meme(
2237
+ ).__send__(
2238
+ :+,
2239
+ ::Myco.find_constant(:C).spc.__send__(:*)
2240
+ ).__send__(
2241
+ :+,
2242
+ ::Myco.find_constant(:T).meme_mark.__send__(
2243
+ :[],
2244
+ :tm
2245
+ )
2246
+ ).__send__(
2247
+ :+,
2248
+ ::Myco.find_constant(:C).spc_nl.__send__(:*)
2249
+ ).__send__(
2250
+ :+,
2251
+ self.meme_either_body_as_block.__send__(
2252
+ :[],
2253
+ :nb
2254
+ )
2255
+ )) { |*| (self.ast.meme(
1852
2256
  self.nlist.first,
1853
2257
  self.nlist,
1854
- nil
2258
+ self.nb
2259
+ ))}.__send__(
2260
+ :/,
2261
+ self.r(self.sepd_decorations.__send__(
2262
+ :[],
2263
+ :nlist
2264
+ )) { |*| (self.ast.meme(
2265
+ self.nlist.first,
2266
+ self.nlist,
2267
+ nil
2268
+ ))}
1855
2269
  ))}
1856
- ))}
2270
+ )
1857
2271
  )}
1858
2272
  )}}.instance)
1859
2273
  )}}.instance