myco 0.1.0.dev

data/lib/myco/parser/peg_parser.kpeg

@@ -0,0 +1,759 @@
+%% name = CodeTools::PegParser
+#%
+
+%% { #%
+  attr_accessor :processor
+  attr_accessor :root_node
+  
+  # Generate an AST::Node of the given type (generated by the @processor)
+  def node type, locator, *args
+    @processor.send :"process_#{type}", locator.line, *args
+  end
+  
+  # Generate a Token with the given type, text, and row_col
+  def token type, text, row_col=nil
+    row_col ||= [current_line, current_column-text.length]
+    Token.new type, text, row_col
+  end
+  
+  # A token is a lightweight unit of text with type and location info
+  # as well as some convenience function for common conversion operations.
+  class Token
+    attr_accessor :type
+    attr_accessor :text
+    attr_accessor :line
+    
+    def inspect
+      [@type, @text, @line].inspect
+    end
+    alias_method :to_s, :inspect
+    
+    def initialize type, text, row_col
+      @type = type
+      @text = text
+      # TODO: integrate columns from location instead of just rows
+      @line = row_col.first
+    end
+    
+    def sym;      @text.to_sym    end
+    def float;    Float(@text)    end
+    def integer;  Integer(@text)  end
+  end
+}
+
+##
+# Things to remember about PEG:
+#
+# Given the choice (a | b | c),
+#   PEG will consume the first matching choice, not the longest.
+# There is no ambiguity in PEG because all rule choices are order-dependent.
+#   This means that you should avoid changing the order of choices
+#   in a rule without being mindful of the consequences.
+#
+# Given a left-recursive set of rules such as
+#   x = a | b | c
+#   a = x "+" x
+# PEG will silently ignore the 'a' rule when trying to contruct 'x' and
+#   not even try to pursue it because it would result in infinite recursion.
+#   To avoid left-recursion while retaining left-associativity,
+#   use an iteration rule instead of a recursion rule.
+#   (see the chained_left_atoms rule)
+
+
+##
+# Toplevel Terminal Categorizations
+
+root = declobj_expr_body:n0  { @root_node = node(:declfile, n0, n0) }
+
+# Declarations
+decl =
+  declobj
+| declstr
+| copen
+
+# Expressions allowable inside object declarations
+declobj_expr =
+  category
+| declobj_expr_not_category
+
+# Expressions allowable inside object declarations that is not a category 
+declobj_expr_not_category =
+  decl
+| cdefn
+| cmeme
+| constant
+| meme
+
+# Expressions allowable inside memes
+meme_expr =
+  return_arg_expr
+| arg_expr
+
+# Expressions allowable as function arguments
+arg_expr =
+  assignment
+| left_chained_atoms
+| dyn_string
+| dyn_symstr
+| expr_atom
+
+# TODO: make expr_atom not redundant with below rules
+# Expression atoms
+expr_atom =
+  decl
+| left_chained_invocations
+| lit_string
+| lit_symstr
+| unary_operation
+| paren_expr
+| constant
+| lit_simple
+| lit_array
+| invoke
+
+# Expression atoms that are not invocation chains
+expr_atom_not_chained =
+  decl
+| lit_string
+| lit_symstr
+| unary_operation
+| paren_expr
+| constant
+| lit_simple
+| lit_array
+| invoke
+
+# Expression atoms that are not strings
+expr_atom_not_string =
+  decl
+| left_chained_invocations
+| unary_operation
+| paren_expr
+| constant
+| lit_simple
+| lit_array
+| invoke
+
+
+##
+# Character Classes
+
+eol_comment = '#' (!c_eol .)*
+
+c_nl     = "\n"
+c_spc    = /[ \t\r\f\v]/ | "\\\n" | eol_comment
+c_spc_nl = c_spc | c_nl
+
+c_eof    = !.
+c_eol    = c_nl | c_eof
+c_any    = .
+
+c_upper  = /[[:upper:]]/
+c_lower  = /[[:lower:]]/ | "_"
+c_num    = /[0-9]/
+c_alpha  = c_lower | c_upper
+c_alnum  = c_alpha | c_num
+c_suffix = '!' | '?'
+
+
+##
+# Tokens
+
+t_CONST_SEP     = < ',' >                     ~token(:t_CONST_SEP,     text)
+t_EXPR_SEP      = < ';' | c_nl >              ~token(:t_EXPR_SEP,      text)
+t_ARG_SEP       = < ',' | c_nl >              ~token(:t_ARG_SEP,       text)
+t_DECLARE_BEGIN = < '{' >                     ~token(:t_DECLARE_BEGIN, text)
+t_DECLARE_END   = < '}' | c_eof >             ~token(:t_DECLARE_END,   text)
+t_MEME_MARK     = < ':' >                     ~token(:t_MEME_MARK,     text)
+t_MEME_BEGIN    = < '{' >                     ~token(:t_MEME_BEGIN,    text)
+t_MEME_END      = < '}' >                     ~token(:t_MEME_END,      text)
+t_PAREN_BEGIN   = < '(' >                     ~token(:t_PAREN_BEGIN,   text)
+t_PAREN_END     = < ')' >                     ~token(:t_PAREN_END,     text)
+t_DEFINE        = < '<' >                     ~token(:t_DEFINE,        text)
+t_REOPEN        = < '<<' >                    ~token(:t_REOPEN,        text)
+t_PARAMS_BEGIN  = < '|' >                     ~token(:t_PARAMS_BEGIN,  text)
+t_PARAMS_END    = < '|' >                     ~token(:t_PARAMS_END,    text)
+t_ARGS_BEGIN    = < '(' >                     ~token(:t_ARGS_BEGIN,    text)
+t_ARGS_END      = < ')' >                     ~token(:t_ARGS_END,      text)
+t_ARRAY_BEGIN   = < '[' >                     ~token(:t_ARRAY_BEGIN,   text)
+t_ARRAY_END     = < ']' >                     ~token(:t_ARRAY_END,     text)
+
+t_CONSTANT      = < (c_upper c_alnum*) >      ~token(:t_CONSTANT,      text)
+t_IDENTIFIER    = < (c_lower c_alnum*) c_suffix? >
+                                              ~token(:t_IDENTIFIER,    text)
+t_SYMBOL        = ':' < (c_lower c_alnum*) >  ~token(:t_SYMBOL,        text)
+
+t_NULL          = < 'null' >                  ~token(:t_NULL,          text)
+t_VOID          = < 'void' >                  ~token(:t_VOID,          text)
+t_TRUE          = < 'true' >                  ~token(:t_TRUE,          text)
+t_FALSE         = < 'false' >                 ~token(:t_FALSE,         text)
+t_SELF          = < 'self' >                  ~token(:t_SELF,          text)
+t_FLOAT         = < c_num+ '.' c_num+ >       ~token(:t_FLOAT,         text)
+t_INTEGER       = < c_num+ >                  ~token(:t_INTEGER,       text)
+
+t_JUMP          = < '->' >                    ~token(:t_JUMP,          text)
+t_DOT           = < '.' >                     ~token(:t_DOT,           text)
+t_QUEST         = < '.' c_spc_nl* '?' >       ~token(:t_QUEST,         text)
+t_SCOPE         = < '::' >                    ~token(:t_SCOPE,         text)
+t_ASSIGN        = < '=' >                     ~token(:t_ASSIGN,        text)
+t_OP_TOPROC     = < '&' >                     ~token(:t_OP_TOPROC,     text)
+t_OP_NOT        = < '!' >                     ~token(:t_OP_NOT,        text)
+t_OP_PLUS       = < '+' >                     ~token(:t_OP_PLUS,       text)
+t_OP_MINUS      = < '-' >                     ~token(:t_OP_MINUS,      text)
+t_OP_MULT       = < '*' >                     ~token(:t_OP_MULT,       text)
+t_OP_DIV        = < '/' >                     ~token(:t_OP_DIV,        text)
+t_OP_MOD        = < '%' >                     ~token(:t_OP_MOD,        text)
+t_OP_EXP        = < '**' >                    ~token(:t_OP_EXP,        text)
+t_OP_AND        = < '&&' >                    ~token(:t_OP_AND,        text)
+t_OP_OR         = < '||' >                    ~token(:t_OP_OR,         text)
+t_OP_COMPARE    = < ('<=>'|'=~'|'=='|'<='|'>='|'<'|'>') >
+                                              ~token(:t_OP_COMPARE,    text)
+
+string_norm = /[^\\\"]/
+t_STRING_BODY   = < string_norm* ("\\" c_any string_norm*)* >
+                                              ~token(:t_STRING_BODY,   text)
+t_STRING_BEGIN  = < '"' >                     ~token(:t_STRING_BEGIN,  text)
+t_STRING_END    = < '"' >                     ~token(:t_STRING_END,    text)
+t_SYMSTR_BEGIN  = < ':"' >                    ~token(:t_SYMSTR_BEGIN,  text)
+
+sstring_norm = /[^\\\']/
+t_SSTRING_BODY  = < sstring_norm* ("\\" c_any sstring_norm*)* >
+                                              ~token(:t_SSTRING_BODY,  text)
+t_SSTRING_BEGIN = < "'" >                     ~token(:t_SSTRING_BEGIN, text)
+t_SSTRING_END   = < "'" >                     ~token(:t_SSTRING_END,   text)
+
+catgry_norm = /[^\\\[\]]/
+t_CATGRY_BODY   = < catgry_norm* ("\\" c_any catgry_norm*)* >
+                                              ~token(:t_CATGRY_BODY,   text)
+t_CATGRY_BEGIN  = < '[' >                     ~token(:t_CATGRY_BEGIN,  text)
+t_CATGRY_END    = < ']' >                     ~token(:t_CATGRY_END,    text)
+
+
+##
+# Simple literals
+
+lit_simple =
+  t_NULL:t0     ~node(:null,  t0)
+| t_VOID:t0     ~node(:void,  t0)
+| t_TRUE:t0     ~node(:true,  t0)
+| t_FALSE:t0    ~node(:false, t0)
+| t_SELF:t0     ~node(:self,  t0)
+| t_FLOAT:t0    ~node(:lit,   t0, t0.float)
+| t_INTEGER:t0  ~node(:lit,   t0, t0.integer)
+| t_SYMBOL:t0   ~node(:lit,   t0, t0.sym)
+
+##
+# Enclosed literals
+
+lit_string =
+  t_STRING_BEGIN  t_STRING_BODY:tb  t_STRING_END
+    ~node(:lit, tb, encode_escapes(tb.text))
+| t_SSTRING_BEGIN t_SSTRING_BODY:tb t_SSTRING_END
+    ~node(:lit, tb, encode_escapes(tb.text))
+
+lit_string_as_symbol = # Used in contexts where a bare string is a symbol
+  t_STRING_BEGIN  t_STRING_BODY:tb  t_STRING_END
+    ~node(:lit, tb, encode_escapes(tb.text).to_sym)
+| t_SSTRING_BEGIN t_SSTRING_BODY:tb t_SSTRING_END
+    ~node(:lit, tb, encode_escapes(tb.text).to_sym)
+
+lit_symstr =
+  t_SYMSTR_BEGIN t_STRING_BODY:tb t_STRING_END
+    ~node(:lit, tb, encode_escapes(tb.text).to_sym)
+
+category_name = # Used only in declobj body
+  t_CATGRY_BEGIN t_CATGRY_BODY:tb t_CATGRY_END
+    ~node(:lit, tb, encode_escapes(tb.text).to_sym)
+
+##
+# String interpolations / juxtapositions
+
+expr_atom_evstr =
+  expr_atom_not_string:n0
+    ~node(:evstr, n0, n0)
+
+dyn_string_parts =
+  (c_spc* expr_atom_evstr:n0 c_spc* lit_string:n1 {[n0,n1]})+:nlist
+    { nlist.flatten }
+
+dyn_string =
+  lit_string:n0 dyn_string_parts:nrest
+    ~node(:dstr, n0, n0.value, nrest)
+
+dyn_symstr =
+  lit_symstr:n0 dyn_string_parts:nrest
+    ~node(:dsym, n0, n0.value.to_s, nrest)
+
+##
+# Constants
+
+constant =
+  constant:n0 t_SCOPE:ts t_CONSTANT:tc  ~node(:colon2, ts, n0, tc.sym)
+| t_SCOPE:ts t_CONSTANT:tc              ~node(:colon3, ts, tc.sym)
+| t_CONSTANT:tc                         ~node(:const,  tc, tc.sym)
+
+const_sep     = (c_spc_nl* t_CONST_SEP c_spc_nl*)+
+
+constant_list =
+  constant:n0 (const_sep constant:n)*:nrest
+    ~node(:array, n0, [n0, *nrest])
+
+##
+# Bare identifiers
+
+# Used in contexts where a bare identifier is a symbol
+id_as_symbol =  t_IDENTIFIER:t0  ~node(:lit, t0, t0.sym)
+
+##
+# Object declarations
+
+declobj_sepd_exprs =
+  declobj_expr:n0 (arg_sep declobj_expr:n)*:nrest arg_sep_opt { [n0, *nrest] }
+
+declobj_expr_body =
+  arg_sep_opt declobj_sepd_exprs:nlist t_DECLARE_END:te
+    ~node(:block, nlist.first, nlist)
+| arg_sep_opt t_DECLARE_END:te
+    ~node(:null, te)
+
+declobj =
+  constant_list:n0 c_spc_nl* t_DECLARE_BEGIN:t declobj_expr_body:n1
+    ~node(:declobj, t, n0, n1)
+
+category_expr =
+  declobj_expr_not_category
+
+category_sepd_exprs =
+  category_expr:n0 (arg_sep category_expr:n)*:nrest { [n0, *nrest] }
+
+category =
+  category_name:n0 arg_sep category_sepd_exprs?:nlist &(arg_sep_opt (t_CATGRY_BEGIN | t_DECLARE_END))
+    ~node(:category, n0, n0,
+      (nlist ? node(:block, nlist.first, nlist) : node(:null, n0)))
+
+copen =
+  constant:n0 c_spc_nl* t_REOPEN:tb c_spc_nl* t_DECLARE_BEGIN declobj_expr_body:n1
+    ~node(:copen, tb, n0, n1)
+
+cdefn =
+  constant:n0 c_spc_nl* t_DEFINE:t c_spc_nl* declobj:n1
+    ~node(:cdefn, t, n0, n1)
+
+##
+# String object declarations
+
+t_DECLSTR_BEGIN =
+  < /[^\s{:,<][^\s]+/ >
+    {
+  
+  # Table of replacement characters to use when calculating
+  # the ending delimiter from the starting delimiter.
+  # Directional characters are replaced with their opposite.
+  @declstr_replace_tbl ||= %w{
+    < > ( ) { } [ ]
+  }
+  
+  # Calculate the ending delimiter to look for and store it
+  @declstr_destrlim = text \
+    .split(/(?<=[^a-zA-Z])|(?=[^a-zA-Z])/)
+    .map { |str|
+      idx = @declstr_replace_tbl.find_index(str)
+      idx.nil? ? str : 
+        (idx.odd? ? @declstr_replace_tbl[idx-1] : @declstr_replace_tbl[idx+1])
+    }
+    .reverse
+    .join ''
+  
+  token(:t_DECLSTR_BEGIN, text)
+}
+
+t_DECLSTR_END =
+  c_spc_nl* < (< /\S+/ > &{text == @declstr_destrlim}) >
+    ~token(:t_DECLSTR_END, text)
+
+s_DECLSTR_BODYLINE =
+  < /[^\n]*\n/ >
+    &{ text =~ /^(\s*)(\S+)/; $2!=@declstr_destrlim }
+    { text }
+
+s_DECLSTR_BODY =
+  s_DECLSTR_BODYLINE*:slist
+    { slist[1..-1].join('') }
+
+declstr_body =
+  t_DECLSTR_BEGIN:tb s_DECLSTR_BODY:st c_spc_nl* t_DECLSTR_END
+    ~node(:str, tb, st)
+
+declstr =
+  constant_list:nc c_spc+ declstr_body:nb
+    ~node(:declstr, nc, nc, nb)
+
+##
+# Jumps
+
+return_arg_expr =
+  arg_expr:n0 c_spc* t_JUMP:to
+    ~node(:return, to, n0)
+
+##
+# Assignment
+
+assignment =
+  local_assignment
+| invoke_assignment
+
+assign_rhs =
+  arg_expr
+
+local_assignment =
+  t_IDENTIFIER:ti c_spc_nl* t_ASSIGN:to c_spc_nl* assign_rhs:rhs
+    ~node(:lasgn, to, ti.sym, rhs)
+
+invoke_assignment_lhs =
+  left_chained_invocations
+| invoke
+
+invoke_assignment =
+  invoke_assignment_lhs:lhs c_spc_nl* t_ASSIGN:to c_spc_nl* assign_rhs:rhs
+    {
+  lhs.name = :"#{lhs.name}="
+  orig_arguments = lhs.arguments && lhs.arguments.body || []
+  lhs.arguments = node(:array, rhs, [rhs, *orig_arguments])
+  lhs
+}
+
+
+##
+# Invoke - Results in a :lambig, :call, or :iter with a :call within
+
+invoke_body =
+  (c_spc_nl* param_list:n)?:np c_spc_nl* meme_enclosed_expr_body:nb
+    { [np, nb] }
+
+invoke =
+  t_IDENTIFIER:tn (c_spc_nl* arg_list:na)?:na (c_spc_nl* invoke_body:n)?:nlist
+    ~node(:invoke, tn, nil, tn.sym, na, *nlist)
+
+op_invoke = # Allow some binary operators to be invoked with a dot
+  op_invoke_id:tn (c_spc_nl* arg_list:na)?:na (c_spc_nl* invoke_body:n)?:nlist
+    ~node(:invoke, tn, nil, tn.sym, na, *nlist)
+
+op_invoke_id =
+  left_op
+
+##
+# Argument lists
+
+arg_sep     = (c_spc* t_ARG_SEP c_spc*)+
+arg_sep_opt = (c_spc | t_ARG_SEP)*
+
+in_arg_normal =
+  in_arg_splat
+| arg_expr:n0 !in_arg_kwarg_mark { n0 }
+
+in_arg_normals =
+  in_arg_normal:n0 (arg_sep in_arg_normal:n)*:nrest
+    { [n0,*nrest] }
+
+in_arg_kwargs =
+  in_arg_kwarg:n0 (arg_sep in_arg_kwarg:n)*:nrest
+    ~node(:hash, n0.first, [n0,*nrest].flatten)
+
+in_arg_kwarg_mark = c_spc_nl* t_MEME_MARK:to
+in_arg_kwarg =
+  id_as_symbol:n0 in_arg_kwarg_mark c_spc_nl* arg_expr:n1
+    { [n0, n1] }
+
+in_arg_splat  =
+  t_OP_MULT:to expr_atom:n0
+    ~node(:splat, to, n0)
+
+in_arg_block  =
+  t_OP_TOPROC:to expr_atom:n0
+    ~node(:block_pass, to, nil, n0)
+
+in_arg_list =
+  in_arg_normals:n0 arg_sep in_arg_kwargs:n1 arg_sep in_arg_block:n2  { [*n0,n1,n2] }
+| in_arg_normals:n0 arg_sep in_arg_kwargs:n1  { [*n0,n1] }
+| in_arg_normals:n0 arg_sep in_arg_block:n1   { [*n0,n1] }
+| in_arg_kwargs:n0  arg_sep in_arg_block:n1   { [n0, n1] }
+| in_arg_normals:n0  { [*n0] }
+| in_arg_kwargs:n0   { [n0] }
+| in_arg_block:n0    { [n0] }
+
+arg_list =
+  t_ARGS_BEGIN:tb arg_sep_opt t_ARGS_END
+    ~args_assemble(tb, node(:array, tb, []))
+| t_ARGS_BEGIN:tb arg_sep_opt in_arg_list:nlist arg_sep_opt t_ARGS_END
+    ~args_assemble(tb, node(:array, tb, nlist))
+
+lit_array =
+  t_ARRAY_BEGIN:tb arg_sep_opt t_ARRAY_END
+    ~args_assemble(tb, node(:array, tb, []))
+| t_ARRAY_BEGIN:tb arg_sep_opt in_arg_list:nlist arg_sep_opt t_ARRAY_END
+    ~args_assemble(tb, node(:array, tb, nlist))
+
+##
+# Parameter lists
+
+param =
+  t_IDENTIFIER:ti c_spc_nl* t_ASSIGN:to c_spc_nl* arg_expr:nv
+    { [:optional, node(:lasgn, ti, ti.sym, nv)] }
+| t_IDENTIFIER:ti c_spc_nl* t_MEME_MARK:to c_spc_nl* arg_expr?:nv
+    { [:kwargs, node(:lasgn, ti, ti.sym, (nv || node(:lit, to, :*)))] }
+| t_OP_EXP c_spc_nl* t_IDENTIFIER:ti     { [:kwrest,   ti.sym] }
+| t_OP_MULT c_spc_nl* t_IDENTIFIER:ti    { [:rest,     ti.sym] }
+| t_OP_TOPROC c_spc_nl* t_IDENTIFIER:ti  { [:block,    ti.sym] }
+| t_IDENTIFIER:ti                        { [:required, ti.sym] }
+
+param_sepd =
+  arg_sep param:n0  { n0 }
+
+param_sepds =
+  param:n0 (arg_sep param:n)*:nrest arg_sep_opt  { [n0, *nrest] }
+
+param_list =
+  t_PARAMS_BEGIN:tb t_PARAMS_END
+    { node(:args, tb, nil, nil, nil, nil, nil, nil, nil) }
+| t_PARAMS_BEGIN:tb param_sepds:plist t_PARAMS_END
+    {
+      required, optional, rest, kwargs, kwrest, block = 6.times.map { [] }
+      
+      required << plist.shift[1] while plist[0] && plist[0][0] == :required
+      optional << plist.shift[1] while plist[0] && plist[0][0] == :optional
+      rest     << plist.shift[1] while plist[0] && plist[0][0] == :rest
+      kwargs   << plist.shift[1] while plist[0] && plist[0][0] == :kwargs
+      kwrest   << plist.shift[1] while plist[0] && plist[0][0] == :kwrest
+      block    << plist.shift[1] while plist[0] && plist[0][0] == :block
+      
+      required = required
+      optional = optional.empty? ? nil : node(:block, tb, optional)
+      rest     = rest.first
+      post     = nil
+      kwargs   = kwargs.empty?   ? nil : node(:block, tb, kwargs)
+      kwrest   = kwrest.first
+      block    = block.first
+      
+      node(:args, tb, required, optional, rest, post, kwargs, kwrest, block)
+    }
+
+##
+# Two-term operators
+
+left_op =
+  t_OP_EXP
+| t_OP_MULT | t_OP_DIV | t_OP_MOD
+| t_OP_PLUS | t_OP_MINUS
+| t_OP_COMPARE
+| t_OP_AND  | t_OP_OR
+
+# Achieve left-associativity through iteration.
+#
+# PEG parsers get tripped up by left recursion
+# (in contrast to LALR parsers, which prefer left recursion).
+# This is a well-understood limitation, but refer to:
+# http://www.dalnefre.com/wp/2011/05/parsing-expression-grammars-part-4/
+# for an easy-to-understand explanation of this problem and this solution.
+#
+left_chained_atoms =
+  expr_atom:n0 (c_spc_nl* left_op:to c_spc_nl* expr_atom:n1 { [to, n1] })+:list
+    {
+  list.unshift n0
+  list.flatten!
+  
+  collapse(list, :t_OP_EXP)
+  collapse(list, :t_OP_MULT, :t_OP_DIV, :t_OP_MOD)
+  collapse(list, :t_OP_PLUS, :t_OP_MINUS)
+  collapse(list, :t_OP_COMPARE)
+  collapse(list, :t_OP_AND, :t_OP_OR) do |n0,op,n1|
+    type = { :t_OP_AND=>:and, :t_OP_OR=>:or }[op.type]
+    node(type, op, n0, n1)
+  end
+  
+  # There should only be one resulting node left
+  raise "Failed to fully collapse left_chained_atoms: #{list}" \
+    unless list.count == 1
+  
+  list.first
+}
+
+##
+# Invocations and Quests (soft-failing invocations)
+
+left_invoke_op =
+  t_QUEST
+| t_DOT
+
+# Achieve left-associativity through iteration.
+# (see left_chained_atoms).
+#
+left_chained_invocations =
+  expr_atom_not_chained:n0 (c_spc_nl* left_invoke_op:to c_spc_nl* (invoke | op_invoke):n1 { [to, n1] })+:list
+    {
+  list.unshift n0
+  list.flatten!
+  
+  collapse(list, :t_DOT, :t_QUEST) do |n0,op,n1|
+    op.type==:t_DOT ? (n1.receiver=n0; n1) : node(:quest, op, n0, n1)
+  end
+  
+  # There should only be one resulting node left
+  raise "Failed to fully collapse left_chained_invocations: #{list}" \
+    unless list.count == 1
+  
+  list.first
+}
+
+##
+# Unary operators
+
+unary_operation =
+  t_OP_NOT:to expr_atom:n0
+    ~node(:call, to, n0, :"!", nil)
+
+##
+# Memes and etc..
+
+t_inln_sep   = !t_ARG_SEP t_EXPR_SEP
+
+inln_sep     = (c_spc* t_inln_sep c_spc*)+
+inln_sep_opt = (c_spc | t_inln_sep)*
+
+expr_sep     = (c_spc* t_EXPR_SEP c_spc*)+
+expr_sep_opt = (c_spc | t_EXPR_SEP)*
+
+meme_inline_sepd_exprs =
+  meme_expr:n0 (inln_sep meme_expr:n)*:nrest inln_sep_opt  { [n0, *nrest] }
+
+meme_sepd_exprs =
+  meme_expr:n0 (expr_sep meme_expr:n)*:nrest expr_sep_opt  { [n0, *nrest] }
+
+meme_inline_expr_body =
+  inln_sep_opt meme_inline_sepd_exprs:nlist
+    ~node(:block, nlist.first, nlist)
+
+meme_expr_body =
+  expr_sep_opt meme_sepd_exprs:nlist t_MEME_END:te
+    ~node(:block, nlist.first, nlist)
+| expr_sep_opt t_MEME_END:te
+    ~node(:null, te)
+
+paren_expr_body =
+  expr_sep_opt meme_sepd_exprs:nlist t_PAREN_END:te
+    { nlist.count==1 ? nlist.first : node(:block, nlist.first, nlist) }
+| expr_sep_opt t_PAREN_END:te
+    ~node(:null, te)
+
+paren_expr =
+  t_PAREN_BEGIN paren_expr_body:n0 { n0 }
+
+meme_enclosed_expr_body =
+  t_MEME_BEGIN meme_expr_body:n0   { n0 }
+
+meme_either_body =
+  meme_enclosed_expr_body
+| meme_inline_expr_body
+
+cmeme =
+  constant:n0 c_spc* t_MEME_MARK:tm c_spc_nl* meme_inline_expr_body:n1
+    ~node(:cdecl, tm, n0, n1)
+
+meme_name =
+  id_as_symbol
+| lit_string_as_symbol
+
+decorator =
+  meme_name:ni arg_list?:na
+    ~node(:deco, ni, ni, na)
+
+decorators_and_meme_name =
+  decorator:n0 (c_spc* decorator:n)*:nrest
+    ~node(:array, n0, [n0, *nrest].reverse)
+
+meme =
+  decorators_and_meme_name:nd c_spc* t_MEME_MARK:tm (c_spc_nl* param_list:n)?:np c_spc_nl* meme_either_body:nb
+    ~node(:meme, tm, nd.body.shift.name, nd, np,  nb)
+| decorators_and_meme_name:nd
+    ~node(:meme, tm, nd.body.shift.name, nd, nil, nil)
+
+
+%% {
+#%
+  # Encode escape characters in string literals
+  # TODO: rigorously test and refine
+  #
+  def encode_escapes str
+    str.gsub /\\(.)/ do "#{$1}" end
+  end
+  
+  # Given a node,op list ([node, op, node, op, ... node]) and operator types,
+  # collapse the (node, op, node) groups where the operator is one of the types
+  #
+  # This function is meant to be called several times on the same list,
+  # with a different set of operator types each time, in order of precedence.
+  #
+  def collapse input, *types
+    output = []
+    
+    # Scan through, reducing or shifting based on the operator
+    while input.count > 2
+      n0 = input.shift
+      op = input.shift
+      
+      if types.include? op.type
+        n1 = input.shift
+        
+        result = block_given? ?
+          yield(n0,op,n1) :
+          node(:call, op, n0, op.sym, node(:array, n1, [n1]))
+        input.unshift result
+      else
+        output.push n0
+        output.push op
+      end
+    end
+    
+    # Push the last item remaining
+    output.push input.shift
+    
+    input.replace output
+  end
+  
+  # Given a locator and an node(:array), refactor the splat-related nodes
+  # in a copy of the original node body and return a replacement for the node.
+  #
+  def args_assemble loc, orig_node
+    list = orig_node.body.dup
+    tmp  = []
+    
+    special_type_check = Proc.new { |x|
+      case x
+      when Myco::ToolSet::AST::SplatValue;   :splat
+      when Myco::ToolSet::AST::ConcatArgs;   :argscat
+      when Myco::ToolSet::AST::PushArgs;     :argspush
+      when Myco::ToolSet::AST::BlockPass;    :block_pass
+      else; nil
+      end
+    }
+    
+    # Get the original value in the new_node
+    tmp << list.shift until list.empty? or special_type_check.call(list.first)
+    new_node = tmp.empty? ? list.shift : node(:array, loc, tmp)
+    
+    # Continue to reduce until all elements have been used
+    until list.empty?
+      arg = list.shift
+      type = special_type_check.call(arg)
+      if type == :block_pass
+        new_node = arg.tap { |n| n.arguments = new_node }
+      elsif type != nil
+        new_node = node(:argscat, loc, new_node, arg)
+      else
+        new_node = node(:argspush, loc, new_node, arg)
+      end
+    end
+    
+    new_node || orig_node
+  end
+  
+}