Beispiel #1
0
 def test_list(self):
     assert parse('(+ 1 2)') == [Symbol.ADD, 1, 2]
     assert parse('(1 2 3 4)') == [1, 2, 3, 4]
     assert parse('(func)') == [
         Symbol('func'),
     ]
     assert parse('()') == []
Beispiel #2
0
 def command(self, cmd: str):
     print('Executing:', cmd)
     result = eval(parse(cmd), env=self.global_env)
     if result is not None:
         if isinstance(result, int) or isinstance(result, float):
             print('Result:', result)
         else:
             print('Result:', type(result))
             print(result)
     return result
Beispiel #3
0
    def _gen_macros(self):
        lisp._eval(
            lisp.parse('''(begin

            (define-macro and (lambda args
               (if (null? args) #t
                   (if (= (length args) 1) (car args)
                       `(if ,(car args) (and ,@(cdr args)) #f)))))

            ;; More macros can also go here

        )'''), self.env)
Beispiel #4
0
 def test_strings(self):
     assert parse('"foobar"') == "foobar"
     assert parse('"foo bar"') == "foo bar"
     assert parse(r'"foo\nbar"') == "foo\nbar"
     assert parse(r'"foo\tbar"') == "foo\tbar"
     assert parse(r'"foo\tbar"') == "foo\tbar"
     assert parse(r'"foo\"bar\""') == "foo\"bar\""
Beispiel #5
0
def main(prompt="lispy> "):
    scheme_completer = WordCompleter(["begin", "call/cc"])
    session = PromptSession(lexer=PygmentsLexer(SchemeLexer),
                            completer=scheme_completer)

    while True:
        try:
            text = session.prompt(prompt)
            x = parse(text)
            if x is eof_object:
                return
            val = eval(x)
            if val is not None:
                print(to_string(val))
        except KeyboardInterrupt:
            continue
        except EOFError:
            break
        except Exception as e:
            print(f"{type(e).__name__}: {e}")
    print("GoodBye!")
Beispiel #6
0
 def test_let(self):
     assert parse(':let {x = 1} in (+ x 1)')       == [Symbol.LET, [[x, 1]], [Symbol.ADD, x, 1]]
     assert parse(':let {x = 1 y = 2} in (+ x y)') == [Symbol.LET, [[x, 1], [y, 2]], [Symbol.ADD, x, y]]
Beispiel #7
0
from lispy import var, env, Symbol, parse, eval

run = lambda src, env=None: eval(parse(src), env)
x, y, a, b, c, f, g, h, op = map(Symbol, 'x y a b c f g h op'.split())


class TestGrammarSimple:
    def test_infix(self):
        assert parse('[1 + 2]') == [Symbol.ADD, 1, 2]
        assert parse('[a b c]') == [b, a, c]

    def test_let(self):
        assert parse(':let {x = 1} in (+ x 1)')       == [Symbol.LET, [[x, 1]], [Symbol.ADD, x, 1]]
        assert parse(':let {x = 1 y = 2} in (+ x y)') == [Symbol.LET, [[x, 1], [y, 2]], [Symbol.ADD, x, y]]

    def test_if(self):
        assert parse(':if #t then: 42 :else: 0') == [Symbol.IF, True, 42, 0]


class TestGrammarExtended:
    def test_infix(self):
        assert parse('[(f a) (op) (g b)]') == [[op], [f, a], [g, b]]

    def test_let(self):
        assert parse(':let {x = (+ 1 1)} in (+ x 1)') == [Symbol.LET, [[x, [Symbol.ADD, 1, 1]]], [Symbol.ADD, x, 1]]

    def test_if(self):
        assert parse(':if (h a) then: (f b) :else: (g c)') == [Symbol.IF, [h, a], [f, b], [g, c]]
        assert parse(':if #f then: 40 :elif #t then: 42 :else: 0') == [Symbol.IF, False, 40, [Symbol.IF, True, 42, 0]]

Beispiel #8
0
 def test_quote_is_converted_to_sexpr(self):
     assert parse("'42") == [Symbol.QUOTE, 42]
     assert parse("'1") == [Symbol.QUOTE, 1]
     assert parse("'x") == [Symbol.QUOTE, x]
     assert parse("'(1 2 3)") == [Symbol.QUOTE, [1, 2, 3]]
     assert parse("'(+ 40 2)") == [Symbol.QUOTE, [Symbol.ADD, 40, 2]]
Beispiel #9
0
 def _parse(self, cmd):
     return lisp.parse(cmd)
Beispiel #10
0
 def test_infix(self):
     assert parse('[1 + 2]') == [Symbol.ADD, 1, 2]
     assert parse('[a b c]') == [b, a, c]
Beispiel #11
0
 def test_let(self):
     assert parse(':let {x = (+ 1 1)} in (+ x 1)') == [Symbol.LET, [[x, [Symbol.ADD, 1, 1]]], [Symbol.ADD, x, 1]]
Beispiel #12
0
 def test_atomic(self):
     assert parse('#t') is True
     assert parse('#f') is False
     assert parse('x') == x
     assert parse('+') == Symbol('+')
Beispiel #13
0
def _postprocess_line(line):
    res = ''
    for word in lispy.parse(line):
        res += _postprocess_word(word) + ' '
    # remove the last space
    return res[:-1]
  words = [edge.there.name for edge in edges if(re.match("^"+string, edge.there.name))]
  return words, len(words)

stageFile = raw_input("Enter the stage text filename: ").strip()
reader = StageReader(stageFile)
reader.printMatrix(reader.graph.m)
#reader.printMatrix(reader.graph.mPrime)

current = reader.graph.nodes[0]
while True:
  outer = re.compile("\((.+)\)")
  conv = outer.search(current.description)
  if conv:
    for string in conv.groups():
        for part in lispy.sexp("("+string+")"):
            eval(lispy.parse(part))
  print "\n"+ current.description
  if len(current.out) > 0:
    for edge in current.out:
      print "(",edge.there.name,")", edge.description
    next = raw_input("\nWhat would you like to do next? > ").strip()
    matched, length = match(next, current.out)
    if length > 1 or length < 1:
      current = current
      print "\nThe name you entered matched", "none" if length < 1 else "more than one", "!"
    else:
      current = reader.graph.node(matched[0])
  else:
    print "Congratulations, you have finished the game!"
    break
Beispiel #15
0
 def test_if(self):
     assert parse(':if #t then: 42 :else: 0') == [Symbol.IF, True, 42, 0]
Beispiel #16
0
 def test_nested_list(self):
     assert parse('(1 (2 (3 4)))') == [1, [2, [3, 4]]]
     assert parse('((1 2 3))') == [[1, 2, 3]]
Beispiel #17
0
 def test_infix(self):
     assert parse('[(f a) (op) (g b)]') == [[op], [f, a], [g, b]]
Beispiel #18
0
 def test_numbers(self):
     assert parse('42') == 42
     assert parse('3.14') == 3.14
     assert parse('-3.14') == -3.14
Beispiel #19
0
 def test_if(self):
     assert parse(':if (h a) then: (f b) :else: (g c)') == [Symbol.IF, [h, a], [f, b], [g, c]]
     assert parse(':if #f then: 40 :elif #t then: 42 :else: 0') == [Symbol.IF, False, 40, [Symbol.IF, True, 42, 0]]
Beispiel #20
0
def test_e2e(code, expected):
    assert evaluate(compile_bytecode(parse(tokenize(code)))) == expected
Beispiel #21
0
            ("'(one 2 3)", ['one', 2, 3]),
            ("(define L (list 1 2 3))", None),
            ("`(testing ,@L testing)", ['testing', 1, 2, 3, 'testing']),
            ("`(testing ,L testing)", ['testing', [1, 2, 3], 'testing']),
            ("`,@L", SyntaxError),
            ("""'(1 ;test comments '
             ;skip this line
             2 ; more ; comments ; ) )
             3) ; final comment""", [1, 2, 3]),
        ]

        for (x, expected) in tests:
            result = ''

            try:
                result = lispy.eval(lispy.parse(x))
                print(x, '=>', lispy.to_string(result))
                ok = (result == expected)
            except Exception as e:
                print(x, '=raises=>', type(e).__name__, e)
                ok = inspect.isclass(expected) and issubclass(
                    expected, Exception) and isinstance(e, expected)
            if not ok:
                print('expression: %s' % x)
                print('    actual: %s' % result)
                print('  expected: %s' % expected)
                break
        else:
            print('PASS')

    else:
Beispiel #22
0
def test_parse(tokens, expected):
    """assert tokens parse correctly"""
    assert parse(tokens) == expected