myco 0.1.8 → 0.1.9

data/lib/myco/code_tools/AST/ToRuby.my.rb

@@ -214,26 +214,28 @@
     g.add(self.body)
     g.add("}")
   )})}
-  ::Myco.find_constant(:DeclareMeme).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.with_nested_var_scope(self.body_implementation) { || (
-    g.var_scope_declare_locals(*self.parameters.names)
-    g.add("declare_meme(")
-    g.add("#{self.name.inspect}, ")
-    g.add(self.decorations)
-    g.add(", nil, ::Myco.cscope.dup)")
-    g.add(" { ")
-    g.add(self.parameters)
-    g.add(" ")
-    g.add(self.body)
-    g.add("}")
-  )})})}
-  ::Myco.find_constant(:DeclareDecorator).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    g.add("[#{self.name.value.inspect}, [")
-    g.list(
-      self.arguments.body,
-      ",",
-      {:auto_lines => true}
-    )
-    g.add("]]")
+  ::Myco.find_constant(:DeclareMeme).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+    name = self.decorations.last
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", name.node_type.__send__(
+      :==,
+      :symbol
+    )) {(
+      g.add("declare_meme(")
+      g.list(
+        [
+          self.effective_name,
+          self.effective_decorations,
+          self.effective_body
+        ],
+        ",",
+        {:auto_lines => true}
+      )
+      g.add(")")
+    )}) {g.add(::Myco.find_constant(:ConstantAssignment).new({
+      :line => self.line,
+      :constant => self.effective_name,
+      :value => self.effective_body.block.body
+    }))}
   )})}
   ::Myco.find_constant(:RequiredParameter).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add("#{self.name}"))})}
   ::Myco.find_constant(:OptionalParameter).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
@@ -334,9 +336,9 @@
     g.add(self.body)
   )})}
   ::Myco.find_constant(:Block).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.with_nested_var_scope(self) { || (
-    g.var_scope_declare_locals(*self.parameters.names)
+    g.var_scope_declare_locals(*self.effective_parameters.names)
     g.add(" ")
-    g.add(self.parameters)
+    g.add(self.effective_parameters)
     g.add(" ")
     g.add(self.body)
   )})})}

data/lib/myco/code_tools/Parser.my

@@ -1,11 +1,12 @@
 
 # TODO: include Pegleromyces library in a better way than clone into subdir
 import as(:Pegleromyces) 'parser/pegleromyces/lib/pegleromyces.my'
+::Pegleromyces: Pegleromyces
 
 import 'parser/MycoGrammar.my'
 import 'parser/MycoBuilder.my'
 
-CodeTools::Parser: Pegleromyces::BytecodeParser {
+CodeTools::Parser: Pegleromyces::String::Parser {
   const grammar: MycoGrammar
   const builder: MycoBuilder
   

data/lib/myco/code_tools/Parser.my.rb

@@ -5,9 +5,10 @@
     [:as, [:Pegleromyces]],
     [:import, []]
   ], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco::Pegleromyces = (::Myco.find_constant(:Pegleromyces))
   declare_meme(:"parser/MycoGrammar.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"parser/MycoBuilder.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.find_constant(:CodeTools)::Parser = (::Myco::Component.new([::Myco.find_constant(:Pegleromyces)::BytecodeParser], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  ::Myco.find_constant(:CodeTools)::Parser = (::Myco::Component.new([::Myco.find_constant(:Pegleromyces)::String::Parser], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
   .tap { |__c__| __c__.__last__ = __c__.component_eval {(
     declare_meme(:grammar, [[:const, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:MycoGrammar))}
     declare_meme(:builder, [[:const, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:MycoBuilder))}

data/lib/myco/code_tools/parser/MycoBuilder.my

@@ -40,8 +40,8 @@ MycoBuilder: BasicObject {
     output = []
     
     # Scan through, reducing or shifting based on the operator
-    loop {
-      (input.count > 2) || break
+    Loop.run {
+      (input.count > 2) || Loop.break
       n0 = input.shift
       op = input.shift
       

data/lib/myco/code_tools/parser/MycoBuilder.my.rb

@@ -61,11 +61,11 @@
   ))})}
   declare_meme(:collapse, [], nil, ::Myco.cscope.dup) { |input, *types, &block| (
     output = []
-    self.loop { || (
+    ::Myco.find_constant(:Loop).run { || (
       ::Myco.branch_op(:"||", input.count.__send__(
         :>,
         2
-      )) {self.__send__(:break)}
+      )) {::Myco.find_constant(:Loop).__send__(:break)}
       n0 = input.shift
       op = input.shift
       ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", types.__send__(

data/lib/myco/code_tools/parser/MycoGrammar.my

@@ -30,8 +30,6 @@ rule declobj_expr:
 rule declobj_expr_not_category:
   decl
 / cdefn
-/ cmeme
-/ constant
 / meme
 
 # Expressions allowable inside memes
@@ -114,6 +112,10 @@ rule block_body:
   r(C.spc_nl.* + param_list.-[:np] + C.spc_nl.* + meme_enclosed_expr_body[:nb])
     { ast.block(nb, np, nb) }
 
+rule open_block_body:
+  r(C.spc_nl.* + param_list.-[:np] + C.spc_nl.* + meme_inline_expr_body[:nb])
+    { ast.block(nb, np, nb) }
+
 ##
 # Enclosed literals
 
@@ -277,6 +279,10 @@ rule invoke:
   r(T.identifier[:tn] + opt_arg_list[:na] + opt_block_body[:nb])
     { ast.invoke(tn, null, tn.sym, na, nb) }
 
+rule invoke_classic_form:
+  r(T.identifier[:tn] + C.spc.* + arg_list[:na])
+    { ast.invoke(tn, null, tn.sym, na, null) }
+
 rule op_invoke: # Allow some binary operators to be invoked with a dot
   r(op_invoke_id[:tn] + opt_arg_list[:na] + opt_block_body[:nb])
     { ast.invoke(tn, null, tn.sym, na, nb) }
@@ -521,7 +527,7 @@ rule unary_operation:
 # TODO: this should work without the call to 'inner'
 # Currently, without this call, an unbalanced tidx_stack occurs
 # in the Processor due to an extra :t_start capture symbol emitted
-# by the BytecodeParser with no matching :t_end to clear it.
+# by the String::Parser with no matching :t_end to clear it.
 rule t_inln_sep:   !T.arg_sep.inner + T.expr_sep
 
 rule inln_sep:     (C.spc.* + t_inln_sep + C.spc.*).+
@@ -566,28 +572,21 @@ rule paren_expr:
 rule meme_enclosed_expr_body:
   r(T.meme_begin + meme_expr_body[:n0]) { n0 }
 
-rule meme_either_body:
-  meme_enclosed_expr_body
-/ meme_inline_expr_body
-
-rule cmeme:
-  r(constant[:n0] + C.spc.* + T.meme_mark[:tm] + C.spc_nl.* + meme_inline_expr_body[:n1])
-    { ast.cdecl(tm, n0, n1) }
+rule meme_either_body_as_block:
+  r((block_body / open_block_body)[:n0]) { ast.blklit(n0, n0) }
 
-rule meme_name:
-  id_as_symbol
+rule decoration:
+  invoke_classic_form
+/ id_as_symbol
 / lit_string_as_symbol
+/ constant
 
-rule decorator:
-  r(meme_name[:ni] + arg_list.-[:na])
-    { ast.deco(ni, ni, na) }
-
-rule sepd_decorator:
-  r(C.spc.* + decorator[:n]) { n }
+rule sepd_decoration:
+  r(C.spc.* + decoration[:n]) { n }
 
-rule decorators_and_meme_name:
-  r(decorator[:n0] + sepd_decorator.*[:nrest])
-    { ast.array(n0, [n0, *nrest].reverse) }
+rule sepd_decorations:
+  r(decoration[:n0] + sepd_decoration.*[:nrest])
+    { [n0, *nrest] }
 
 rule meme:
   r(decorators_and_meme_name[:nd]
@@ -597,4 +596,12 @@ rule meme:
     { ast.meme(tm, nd.body.shift.name, nd, np, nb) }
 / r(decorators_and_meme_name[:nd])
     { ast.meme(nd, nd.body.shift.name, nd, null, null) }
+
+rule meme:
+  r(sepd_decorations[:nlist]
+      + C.spc.* + T.meme_mark[:tm]
+      + C.spc_nl.* + meme_either_body_as_block[:nb])
+    { ast.meme(nlist.first, nlist, nb) }
+/ r(sepd_decorations[:nlist])
+    { ast.meme(nlist.first, nlist, null) }
 }

data/lib/myco/code_tools/parser/MycoGrammar.my.rb

@@ -32,12 +32,6 @@
       declare_meme(:declobj_expr_not_category, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.decl.__send__(
         :/,
         self.cdefn
-      ).__send__(
-        :/,
-        self.cmeme
-      ).__send__(
-        :/,
-        self.constant
       ).__send__(
         :/,
         self.meme
@@ -235,6 +229,26 @@
         self.np,
         self.nb
       ))})}
+      declare_meme(:open_block_body, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:C).spc_nl.__send__(:*).__send__(
+        :+,
+        self.param_list.__send__(:-).__send__(
+          :[],
+          :np
+        )
+      ).__send__(
+        :+,
+        ::Myco.find_constant(:C).spc_nl.__send__(:*)
+      ).__send__(
+        :+,
+        self.meme_inline_expr_body.__send__(
+          :[],
+          :nb
+        )
+      )) { || (self.ast.block(
+        self.nb,
+        self.np,
+        self.nb
+      ))})}
       declare_meme(:lit_string, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).string_begin.__send__(
         :+,
         ::Myco.find_constant(:T).string_body.__send__(
@@ -768,6 +782,25 @@
         self.na,
         self.nb
       ))})}
+      declare_meme(:invoke_classic_form, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).identifier.__send__(
+        :[],
+        :tn
+      ).__send__(
+        :+,
+        ::Myco.find_constant(:C).spc.__send__(:*)
+      ).__send__(
+        :+,
+        self.arg_list.__send__(
+          :[],
+          :na
+        )
+      )) { || (self.ast.invoke(
+        self.tn,
+        nil,
+        self.tn.sym,
+        self.na,
+        nil
+      ))})}
       declare_meme(:op_invoke, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.op_invoke_id.__send__(
         :[],
         :tn
@@ -1693,77 +1726,46 @@
           :n0
         )
       )) { || (self.__send__(:n0))})}
-      declare_meme(:meme_either_body, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.meme_enclosed_expr_body.__send__(
+      declare_meme(:meme_either_body_as_block, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.block_body.__send__(
         :/,
-        self.meme_inline_expr_body
-      ))}
-      declare_meme(:cmeme, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.constant.__send__(
+        self.open_block_body
+      ).__send__(
         :[],
         :n0
-      ).__send__(
-        :+,
-        ::Myco.find_constant(:C).spc.__send__(:*)
-      ).__send__(
-        :+,
-        ::Myco.find_constant(:T).meme_mark.__send__(
-          :[],
-          :tm
-        )
-      ).__send__(
-        :+,
-        ::Myco.find_constant(:C).spc_nl.__send__(:*)
-      ).__send__(
-        :+,
-        self.meme_inline_expr_body.__send__(
-          :[],
-          :n1
-        )
-      )) { || (self.ast.cdecl(
-        self.tm,
+      )) { || (self.ast.blklit(
         self.__send__(:n0),
-        self.__send__(:n1)
+        self.__send__(:n0)
       ))})}
-      declare_meme(:meme_name, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.id_as_symbol.__send__(
+      declare_meme(:decoration, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.invoke_classic_form.__send__(
+        :/,
+        self.id_as_symbol
+      ).__send__(
         :/,
         self.lit_string_as_symbol
-      ))}
-      declare_meme(:decorator, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.meme_name.__send__(
-        :[],
-        :ni
       ).__send__(
+        :/,
+        self.constant
+      ))}
+      declare_meme(:sepd_decoration, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:C).spc.__send__(:*).__send__(
         :+,
-        self.arg_list.__send__(:-).__send__(
-          :[],
-          :na
-        )
-      )) { || (self.ast.deco(
-        self.ni,
-        self.ni,
-        self.na
-      ))})}
-      declare_meme(:sepd_decorator, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:C).spc.__send__(:*).__send__(
-        :+,
-        self.decorator.__send__(
+        self.decoration.__send__(
           :[],
           :n
         )
       )) { || (self.n)})}
-      declare_meme(:decorators_and_meme_name, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.decorator.__send__(
+      declare_meme(:sepd_decorations, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.decoration.__send__(
         :[],
         :n0
       ).__send__(
         :+,
-        self.sepd_decorator.__send__(:*).__send__(
+        self.sepd_decoration.__send__(:*).__send__(
           :[],
           :nrest
         )
-      )) { || (self.ast.array(
+      )) { || ([
         self.__send__(:n0),
-        [
-          self.__send__(:n0),
-          *self.nrest
-        ].reverse
-      ))})}
+        *self.nrest
+      ])})}
       declare_meme(:meme, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.decorators_and_meme_name.__send__(
         :[],
         :nd
@@ -1816,6 +1818,42 @@
           nil
         ))}
       ))}
+      declare_meme(:meme, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.sepd_decorations.__send__(
+        :[],
+        :nlist
+      ).__send__(
+        :+,
+        ::Myco.find_constant(:C).spc.__send__(:*)
+      ).__send__(
+        :+,
+        ::Myco.find_constant(:T).meme_mark.__send__(
+          :[],
+          :tm
+        )
+      ).__send__(
+        :+,
+        ::Myco.find_constant(:C).spc_nl.__send__(:*)
+      ).__send__(
+        :+,
+        self.meme_either_body_as_block.__send__(
+          :[],
+          :nb
+        )
+      )) { || (self.ast.meme(
+        self.nlist.first,
+        self.nlist,
+        self.nb
+      ))}.__send__(
+        :/,
+        self.r(self.sepd_decorations.__send__(
+          :[],
+          :nlist
+        )) { || (self.ast.meme(
+          self.nlist.first,
+          self.nlist,
+          nil
+        ))}
+      ))}
     )}
   )}}.instance)
 )}}.instance

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces.my

@@ -1,15 +1,14 @@
 
-import 'pegleromyces/Patterns.my'
-import 'pegleromyces/Constructions.my'
-
-import 'pegleromyces/Instructions.my'
-import 'pegleromyces/Machine.my'
-
-import 'pegleromyces/Processor.my'
-import 'pegleromyces/Builder.my'
+import 'pegleromyces/Common.my'
+import 'pegleromyces/Capture.my'
+import 'pegleromyces/Composite.my'
+import 'pegleromyces/String.my'
+import 'pegleromyces/Stream.my'
 
 import 'pegleromyces/Grammar.my'
-import 'pegleromyces/Parser.my'
 
-import 'pegleromyces/BytecodeInstructions.my'
-import 'pegleromyces/BytecodeParser.my'
+import 'pegleromyces/BytecodeHelpers.my'
+import 'pegleromyces/Common/Parser.my'
+import 'pegleromyces/String/Parser.my'
+import 'pegleromyces/Stream/Parser.my'
+import 'pegleromyces/Processor.my'

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces.my.rb

@@ -1,14 +1,15 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:"pegleromyces/Patterns.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"pegleromyces/Constructions.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"pegleromyces/Instructions.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"pegleromyces/Machine.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"pegleromyces/Processor.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"pegleromyces/Builder.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"pegleromyces/Common.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"pegleromyces/Capture.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"pegleromyces/Composite.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"pegleromyces/String.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"pegleromyces/Stream.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"pegleromyces/Grammar.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"pegleromyces/Parser.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"pegleromyces/BytecodeInstructions.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"pegleromyces/BytecodeParser.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"pegleromyces/BytecodeHelpers.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"pegleromyces/Common/Parser.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"pegleromyces/String/Parser.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"pegleromyces/Stream/Parser.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"pegleromyces/Processor.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
 )}}.instance