예제 #1
0
파일: lisp_prims.py 프로젝트: kuangyh/chord
def is_prop_fetch(src):
    if type(src) is not tuple:
        return False
    if len(src) > 2 and src[1] == lisp.Symbol('->') and (lisp.getop(
            src[-1]) == ':' or not isinstance(src[-1], tuple)):
        return True
    return False
예제 #2
0
파일: lisp_prims.py 프로젝트: kuangyh/chord
def is_prop_fetch(src):
    if type(src) is not tuple:
	return False
    if len(src) > 2 and src[1] == lisp.Symbol('->') and (
	    lisp.getop(src[-1]) == ':' or not isinstance(src[-1], tuple)):
	return True
    return False
예제 #3
0
def prim_try(compiler, source):
    curr_stat = 'try'

    # Step 1: Parse the list
    try_block = []
    except_blocks = []
    finally_block = []

    try_var = pycode.name('try')

    for item in source[1:]:
	if lisp.getop(item) == 'except':
	    if not type(item[1]) is tuple and len(item[1]) == 2 and (
		    type(item[1][0]) is lisp.Symbol and
		    type(item[1][1]) is lisp.Symbol):
		raise SyntaxError, item
	    curr_stat = 'except'
	    (except_blocks.append((item[1][0].name, item[1][1].name, item[2:])))
	elif lisp.getop(item) == 'finally':
	    finally_block.extend(item[1:])
	else:
	    if curr_stat != 'try':
		raise SyntaxError, source
	    try_block.append(item)

    if not except_blocks and not finally_block:
	raise SyntaxError, source

    # Try part
    output_tpl = 'try:\n  %s = $#\n' % (try_var,)
    output_codes = [compiler.compile_block(try_block)]
    # Except part
    for type_sym, bind_sym, code in except_blocks:
	output_tpl += 'except %s, %s:\n  %s = $#\n' % (
		type_sym, bind_sym, try_var)	
	output_codes.append(compiler.compile_block(code))
    if finally_block:
	output_tpl += 'finally:\n  $#\n'
	output_codes.append(compiler.compile_block(finally_block))
    output_tpl += try_var
    return pycode.create(output_tpl, *output_codes)
예제 #4
0
파일: lisp_class.py 프로젝트: kuangyh/chord
def prim_class(compiler, source):
    class_name = source[1].name
    if len(source) > 2 and lisp.getop(source[2]) == ':':
        extends = [x.name for x in source[2][1:]]
        block = source[3:]
    else:
        extends = ['object']
        block = source[2:]

    tpl = 'class %s(%s):\n' % (class_name, ','.join(extends))
    if block:
        tpl += '  $#\n' + class_name
        return pycode.create(tpl, compiler.compile_block(block))
    else:
        tpl += '  pass\n' + class_name
        return pycode.create(tpl)
예제 #5
0
파일: lisp_class.py 프로젝트: kuangyh/chord
def prim_class(compiler, source):
    class_name = source[1].name
    if len(source) > 2 and lisp.getop(source[2]) == ':':
	extends = [x.name for x in source[2][1:]]
	block = source[3:]
    else:
	extends = ['object']
	block = source[2:]

    tpl = 'class %s(%s):\n' % (class_name, ','.join(extends))
    if block:
	tpl += '  $#\n' + class_name
	return pycode.create(tpl, compiler.compile_block(block))
    else:
	tpl += '  pass\n' + class_name
	return pycode.create(tpl)
예제 #6
0
파일: lisp_fn.py 프로젝트: kuangyh/chord
def _parse_arglist(arglist):
    args = []
    kwargs = []
    kwargs_source = []
    idx = 0
    while idx < len(arglist):
        curr = arglist[idx]
	if type(curr) is lisp.Symbol and curr.name in ('.', '..'):
	    args.append(curr.name.replace('.', '*') + arglist[idx + 1].name)
	    idx += 1
        elif type(curr) is lisp.Symbol:
            args.append(curr.name)
        elif lisp.getop(curr) == ':':
            if type(curr[1]) is not lisp.Symbol:
                raise SyntaxError, arglist
            kwargs.append(curr[1].name)
            kwargs_source.append(arglist[idx + 1])
            idx += 1
        else:
            raise SyntaxError, arglist
        idx += 1
    return args, kwargs, kwargs_source
예제 #7
0
파일: lisp_fn.py 프로젝트: kuangyh/chord
def _parse_arglist(arglist):
    args = []
    kwargs = []
    kwargs_source = []
    idx = 0
    while idx < len(arglist):
        curr = arglist[idx]
        if type(curr) is lisp.Symbol and curr.name in ('.', '..'):
            args.append(curr.name.replace('.', '*') + arglist[idx + 1].name)
            idx += 1
        elif type(curr) is lisp.Symbol:
            args.append(curr.name)
        elif lisp.getop(curr) == ':':
            if type(curr[1]) is not lisp.Symbol:
                raise SyntaxError, arglist
            kwargs.append(curr[1].name)
            kwargs_source.append(arglist[idx + 1])
            idx += 1
        else:
            raise SyntaxError, arglist
        idx += 1
    return args, kwargs, kwargs_source
예제 #8
0
파일: proc.py 프로젝트: kuangyh/chord
    def compile_pattern_element(self, element):
	proc_var = lisp.env_curr()

	# '_' is a blank space holder that do nothing
	if element == _S('_'):
	    return pycode.create(proc_var, shortcut_nop = True)

	# Name binding
	bind_to, may_raise = Compiler.get_binding(element)
	if bind_to is not None:
	    return pycode.create(
		    '%s=%s\n%s' % (bind_to, proc_var, proc_var),
		    shortcut_bind = [bind_to],
		    raise_random = may_raise)

	opname = lisp.getop(element)
	# Force equal testing
	if opname == '\'':
	    return self.compile_equal(element[1])

	# Type checking
	if opname == ':':
	    # NOTE: infact, type checking expression could throw exception
	    return self.compile_test((_S('isinstance'), _S('_'), element[1]))

	if opname == '?':
	    return self.compile_test(*element[1:]).add_meta(raise_random = True)

	# Expanded matchings
	if opname in self.EXTS:
	    return self.EXTS[opname](self, element)

	# Extractor
	if type(element) is tuple and len(element) > 0:
	    return self.compile_call(
		    (_S('#'),) + element[1:],
		    (element[0], _S('_'))).add_meta(raise_random = True)
	# Now all come to the structual matching
	return self.compile_pattern_struct(element)
예제 #9
0
    def compile_pattern_element(self, element):
        proc_var = lisp.env_curr()

        # '_' is a blank space holder that do nothing
        if element == _S('_'):
            return pycode.create(proc_var, shortcut_nop=True)

        # Name binding
        bind_to, may_raise = Compiler.get_binding(element)
        if bind_to is not None:
            return pycode.create('%s=%s\n%s' % (bind_to, proc_var, proc_var),
                                 shortcut_bind=[bind_to],
                                 raise_random=may_raise)

        opname = lisp.getop(element)
        # Force equal testing
        if opname == '\'':
            return self.compile_equal(element[1])

        # Type checking
        if opname == ':':
            # NOTE: infact, type checking expression could throw exception
            return self.compile_test((_S('isinstance'), _S('_'), element[1]))

        if opname == '?':
            return self.compile_test(*element[1:]).add_meta(raise_random=True)

        # Expanded matchings
        if opname in self.EXTS:
            return self.EXTS[opname](self, element)

        # Extractor
        if type(element) is tuple and len(element) > 0:
            return self.compile_call(
                (_S('#'), ) + element[1:],
                (element[0], _S('_'))).add_meta(raise_random=True)
        # Now all come to the structual matching
        return self.compile_pattern_struct(element)
예제 #10
0
파일: lisp_fn.py 프로젝트: kuangyh/chord
def prim_def(compiler, source):
    fn_name = lisp.getop(source[1])
    if fn_name is not None:
        return compile_fn(compiler, fn_name, source[1][1:], source[2:])
    else:
        return compiler.compile((lisp.Symbol('='), source[1], source[2:]))
예제 #11
0
파일: lisp_fn.py 프로젝트: kuangyh/chord
def prim_def(compiler, source):
    fn_name = lisp.getop(source[1])
    if fn_name is not None:
        return compile_fn(compiler, fn_name, source[1][1:], source[2:])
    else:
        return compiler.compile((lisp.Symbol('='), source[1], source[2:]))
예제 #12
0
파일: proc.py 프로젝트: kuangyh/chord
def is_proc(node):
    return lisp.getop(node) in ('#', '=>')
예제 #13
0
def is_proc(node):
    return lisp.getop(node) in ('#', '=>')