Пример #1
0
def fun_macro_grammar(klass1, klass2):
  return (
  # fun. a(x)[...],  fun. a(x) <= at[...][...]
    (getattr(vv.name)+
     any(~call(__.args) +assign(__.args, getvalue_default(__.args, ()))
          + some(getitem_to_list(__.body), __.body, __.bodies), 
          (__.args, __.bodies), vv.rules)
        +eoi+make_fun1(vv.name, vv.rules, klass2))
  # fun. a(x) >= [...],  fun. a(x) <= at[...][...]
  | (getattr(vv.name)+call(vv.args)+ge(vv.body)+eoi
     +make_fun2(vv.name,vv.args, vv.body, klass2))
  # fun. a(x) <= [...],  fun. a(x) <= at[...][...]
  | (getattr(vv.name)+call(vv.args)+le(vv.body)+eoi
     +make_fun3(vv.name,vv.args, vv.body, klass2))
  #  fun. a== at(..)[...]
  | (getattr(vv.name)+eq(vv.rules)+eoi
     +make_fun4(vv.name, vv.rules, klass1))
  #  fun. a>= at(..)[...]
  | (getattr(vv.name)+ge(vv.rules)+eoi+make_fun5(vv.name,vv.rules, klass2))
  #  fun. a<= at(..)[...]
  | (getattr(vv.name)+le(vv.rules)+eoi+make_fun6(vv.name,vv.rules, klass2))
  #  fun(args) [...](args)[...][...]
  | (some(may(call(__.args)) +assign(__.args, getvalue_default(__.args, ()))
          + some(getitem_to_list(__.body), __.body, __.bodies), 
          (__.args, __.bodies), vv.rules)
        +eoi+make_fun7(vv.rules, klass1))
  #   - fun.a/3,
  | (getattr(vv.name)+neg+div(vv.arity)+eoi
     +pycall(abolish, getvar(vv.name), vv.arity))
  #- fun.a(x),
  | (getattr(vv.name)+call(vv.args)+neg+eoi
     +make_fun8(vv.name, vv.args, klass2)) #retractall
  #- fun.a(x)[1],
##  | (getattr(vv.name)+call(vv.args)+getitem(vv.index)+neg+assign(result, retract(vv.name, vv.args)))
  )
Пример #2
0
def make_expression(text):
  code = begin(
    sexpression_defines, 
    classic_defines, 
    set_text(text),
    from_(classic, program)(exp), 
    eoi,
    eval_(pycall(cons2tuple, exp)))
  return to_sexpression(code)
Пример #3
0
def fun_macro_grammar(klass1, klass2):
    return (
        # fun. a(x)[...],  fun. a(x) <= at[...][...]
        (getattr(vv.name) + any(
            ~call(__.args) + assign(__.args, getvalue_default(__.args, ())) +
            some(getitem_to_list(__.body), __.body, __.bodies),
            (__.args, __.bodies), vv.rules) + eoi +
         make_fun1(vv.name, vv.rules, klass2))
        # fun. a(x) >= [...],  fun. a(x) <= at[...][...]
        | (getattr(vv.name) + call(vv.args) + ge(vv.body) + eoi +
           make_fun2(vv.name, vv.args, vv.body, klass2))
        # fun. a(x) <= [...],  fun. a(x) <= at[...][...]
        | (getattr(vv.name) + call(vv.args) + le(vv.body) + eoi +
           make_fun3(vv.name, vv.args, vv.body, klass2))
        #  fun. a== at(..)[...]
        | (getattr(vv.name) + eq(vv.rules) + eoi +
           make_fun4(vv.name, vv.rules, klass1))
        #  fun. a>= at(..)[...]
        | (getattr(vv.name) + ge(vv.rules) + eoi +
           make_fun5(vv.name, vv.rules, klass2))
        #  fun. a<= at(..)[...]
        | (getattr(vv.name) + le(vv.rules) + eoi +
           make_fun6(vv.name, vv.rules, klass2))
        #  fun(args) [...](args)[...][...]
        | (some(
            may(call(__.args)) + assign(__.args, getvalue_default(__.args,
                                                                  ())) +
            some(getitem_to_list(__.body), __.body, __.bodies),
            (__.args, __.bodies), vv.rules) + eoi +
           make_fun7(vv.rules, klass1))
        #   - fun.a/3,
        | (getattr(vv.name) + neg + div(vv.arity) + eoi +
           pycall(abolish, getvar(vv.name), vv.arity))
        #- fun.a(x),
        | (getattr(vv.name) + call(vv.args) + neg + eoi +
           make_fun8(vv.name, vv.args, klass2))  #retractall
        #- fun.a(x)[1],
        ##  | (getattr(vv.name)+call(vv.args)+getitem(vv.index)+neg+assign(result, retract(vv.name, vv.args)))
    )
Пример #4
0
def make_pycall(args):
    args = tuple(preparse(x) for x in args)
    return pycall(args[0], args[1:])
Пример #5
0
# my.a, globl.a
## my = element(some(getattr(__._), L('local', __._), y)+eoi)
## globl = element(some(getattr(__._), L('globl', __._), y)+eoi)

## use_item = attr|div(var)|div(str)
## use = 'use'+some(use_item)+mayional(use_block)|any(use_item)+use_block\
##          |some(use_item)+div+use_block

# put.a = 1, put.i.j==(1,2)
put = element(
    'put',
    # put.i.j<<(1,2)
    (getattr(__._) + assign(vv.x, getvar(getvalue(__._))))[1:] % vv.x * vv.vars
    + lshift(vv.value) + eoi +
    pycall(special.set_list, vv.vars, pycall(preparse, vv.value)))


@builtin.function('make_begin')
def make_begin(body):
    return special.begin(*preparse(body))


do = element('do', getitem_to_list(vv.body) + eoi + make_begin(vv.body))

_do, _of, _at, _loop, _always = words('do, of, at, loop, always')


def get_let_vars(binary, klass):
    if not isinstance(binary.y, _VarSymbol): raise DinpySyntaxError()
    if isinstance(binary.x, _VarSymbol): return (binary.x, binary.y)
Пример #6
0
    ([exp_list], and_p(char('['), spaces0(_), from_sexp(sexpression_list)(exp_list), spaces0(_), char(']'))))),
  
  define(punct_expression, function(
    ([L(quote, exp)], and_p(char("'"), from_sexp(sexpression)(exp))),
    ([L(quasiquote, exp)], and_p(char("`"), from_sexp(sexpression)(exp))),
    ([L(unquote_splice, exp)], and_p(literal(",@"), from_sexp(sexpression)(exp))),
    ([L(unquote, exp)], and_p(char(","), from_sexp(sexpression)(exp))))),
  
  define(sexpression_list, function(
    ([Cons(exp, exp_list)], and_p(from_sexp(sexpression)(exp), from_sexp(maybe_spaces)(), from_sexp(sexpression_list)(exp_list))),
    ([nil], null))),
  
  define(sexpression1, function(
    ([exp], and_p(spaces0(_), from_sexp(sexpression_list)(exp), spaces0(_))))),
  
  define(maybe_spaces, function(
    ([], or_p(if_p(and_p(not_lead_chars('([])'), not_follow_chars('([])'), not_p(eoi)),
                   spaces(_)),
          spaces0(_) ) ) ) ),
  
  define(sexpression, function(
     # dynamic grammar arises!
    ([result], and_p(char('{'), from_sexp(sexpression)(exp2), char('}'), 
                     setvalue(result, eval_(pycall(cons2tuple, exp2))))),

    ([exp], from_sexp(atom)(exp)),
    ([exp], from_sexp(bracket_expression)(exp)),
    ([exp], from_sexp(punct_expression)(exp))),
   ),
  )
Пример #7
0
def make_pycall(args):
  args = tuple(preparse(x) for x in args)
  return pycall(args[0], args[1:])
Пример #8
0
  return varcache(name, klass)

# my.a, globl.a
## my = element(some(getattr(__._), L('local', __._), y)+eoi)
## globl = element(some(getattr(__._), L('globl', __._), y)+eoi)

## use_item = attr|div(var)|div(str)
## use = 'use'+some(use_item)+mayional(use_block)|any(use_item)+use_block\
##          |some(use_item)+div+use_block

# put.a = 1, put.i.j==(1,2)
put = element('put',
  # put.i.j<<(1,2)
  (getattr(__._)+assign(vv.x, getvar(__._)))[1:]%vv.x*vv.vars
        +lshift(vv.value)+eoi
        +pycall(special.set_list, vv.vars, pycall(preparse,vv.value))
  )

@builtin.function('make_begin')
def make_begin(body):
  return special.begin(*preparse(body))

do = element('do',
  getitem_to_list(vv.body)+eoi+make_begin(vv.body))

_do, _of, _at, _loop, _always = words('do, of, at, loop, always')

def get_let_vars(binary, klass):
  if not isinstance(binary.y, _VarSymbol): raise DinpySyntaxError()
  if isinstance(binary.x, _VarSymbol): return (binary.x, binary.y)
  if isinstance(binary.x, klass):