Esempio n. 1
0
    def testParse(self):
        ''' Test the parse() method (parsing an entire tree). '''
        class Handler(AbstractHandler):
            def __init__(self):
                super(AbstractHandler, self).__init__()
                self.edge_count = 0
                self.node_count = 0
                self.tree_end_count = 0
                self.leaf_count = 0

            def new_edge(self, bootstrap, length):
                self.edge_count += 1

            def new_tree_begin(self):
                self.node_count += 1

            def new_tree_end(self):
                self.tree_end_count += 1

            def new_leaf(self, name):
                self.leaf_count += 1

        l = lexer.Lexer("((A,B),C);")
        handler = Handler()
        parser = _Parser(l, handler)
        parser.parse_node()
        self.assertEqual(handler.node_count, handler.tree_end_count)
        self.assertEqual(handler.node_count, 2)
        self.assertEqual(handler.edge_count, 4)
        self.assertEqual(handler.leaf_count, 3)
Esempio n. 2
0
    def testParse(self):
        ''' Test the parse() method (parsing an entire tree). '''

        class Handler(AbstractHandler):
            def __init__(self):
                super(AbstractHandler,self).__init__()
                self.edge_count = 0
                self.node_count = 0
                self.tree_end_count = 0
                self.leaf_count = 0

            def new_edge(self,bootstrap,length):
                self.edge_count += 1

            def new_tree_begin(self):
                self.node_count += 1
            def new_tree_end(self):
                self.tree_end_count += 1

            def new_leaf(self,name):
                self.leaf_count += 1


        l = lexer.Lexer("((A,B),C);")
        handler = Handler()
        parser = _Parser(l,handler)
        parser.parse_node()
        self.assertEqual(handler.node_count, handler.tree_end_count)
        self.assertEqual(handler.node_count, 2)
        self.assertEqual(handler.edge_count, 4)
        self.assertEqual(handler.leaf_count, 3)
Esempio n. 3
0
 def test_branch_length_handler(self):
     ''' Test that the handler works, by calculating the branch length
     sum. '''
     l = lexer.Lexer("(('foo' : 0.1, 'bar' : 1.0) : 2, baz)")
     handler = HandlerTest.BranchLengthSum()
     p = _Parser(l,handler)
     p.parse()
     self.assertEqual(handler.sum, 3.1)
Esempio n. 4
0
 def test_branch_length_handler(self):
     ''' Test that the handler works, by calculating the branch total_len
     sum. '''
     l = lexer.Lexer("(('foo' : 0.1, 'bar' : 1.0) : 2, baz)")
     handler = HandlerTest.BranchLengthSum()
     p = _Parser(l, handler)
     p.parse()
     self.assertEqual(handler.sum, 3.1)
Esempio n. 5
0
    def testTreeBuilding(self):
        ''' Test that the tree builder constructs trees correctly when
        parsed. '''
        l = lexer.Lexer("(('foo' : 0.1, 'bar' : 1.0) : 2, baz)")
        handler = _TreeBuilder()
        p = parser._Parser(l,handler)
        p.parse()
        t = handler.get_result()

        self.assertEqual(len(t.get_edges()),2)
        (t1,b1,l1), (t2,b2,l2) = t.get_edges()

        self.assertEqual(len(t1.get_edges()),2)
        self.assertEqual(l1, 2.0)
        self.assertEqual(t2.__class__, Leaf)
        self.assertEqual(l2, None)
        self.assertEqual(t.leaves_identifiers, ['foo','bar','baz'])
Esempio n. 6
0
    def testTreeBuilding(self):
        ''' Test that the tree builder constructs trees correctly when
        parsed. '''
        l = lexer.Lexer("(('foo' : 0.1, 'bar' : 1.0) : 2, baz)")
        handler = _TreeBuilder()
        p = parser._Parser(l, handler)
        p.parse()
        t = handler.get_result()

        self.assertEqual(len(t.get_edges()), 2)
        (t1, b1, l1), (t2, b2, l2) = t.get_edges()

        self.assertEqual(len(t1.get_edges()), 2)
        self.assertEqual(l1, 2.0)
        self.assertEqual(t2.__class__, Leaf)
        self.assertEqual(l2, None)
        self.assertEqual(t.leaves_identifiers, ['foo', 'bar', 'baz'])
Esempio n. 7
0
    def testEdgeListParsing(self):
        ''' Test that the parser handles edge lists correctly. '''
        class EdgeListHandler(AbstractHandler):
            def __init__(self):
                super(AbstractHandler, self).__init__()

                self.bootstrap = []
                self.length = []

            def new_edge(self, bootstrap, length):
                self.bootstrap.append(bootstrap)
                self.length.append(length)

        edge_lexer = lexer.Lexer("first 1 : 0.8, second 0 : 0.5")
        edge_handler = EdgeListHandler()
        edge_parser = _Parser(edge_lexer, edge_handler)
        edge_parser.parse_edge_list()
        self.assertEqual(edge_handler.bootstrap, [1.0, 0.0])
        self.assertEqual(edge_handler.length, [0.8, 0.5])
Esempio n. 8
0
    def testEdgeListParsing(self):
        ''' Test that the parser handles edge lists correctly. '''

        class EdgeListHandler(AbstractHandler):
            def __init__(self):
                super(AbstractHandler,self).__init__()

                self.bootstrap = []
                self.length = []
            def new_edge(self,bootstrap,length):
                self.bootstrap.append(bootstrap)
                self.length.append(length)

        edge_lexer = lexer.Lexer("first 1 : 0.8, second 0 : 0.5")
        edge_handler = EdgeListHandler()
        edge_parser = _Parser(edge_lexer,edge_handler)
        edge_parser.parse_edge_list()
        self.assertEqual(edge_handler.bootstrap,[1.0,0.0])
        self.assertEqual(edge_handler.length,[0.8,0.5])
Esempio n. 9
0
    def testNodeParsing(self):
        ''' Test that the parser handles inner nodes correctly. '''

        # inner nodes are just parenthesis around an edge list, so we
        # reuse the test...
        class EdgeListHandler(AbstractHandler):
            def __init__(self):
                super(AbstractHandler,self).__init__()

                self.bootstrap = []
                self.length = []
            def new_edge(self,bootstrap,length):
                self.bootstrap.append(bootstrap)
                self.length.append(length)

        edge_lexer = lexer.Lexer("(first 1 : 0.8, second 0 : 0.5)")
        edge_handler = EdgeListHandler()
        edge_parser = _Parser(edge_lexer,edge_handler)
        edge_parser.parse_node()
        self.assertEqual(edge_handler.bootstrap,[1.0,0.0])
        self.assertEqual(edge_handler.length,[0.8,0.5])
Esempio n. 10
0
    def testNodeParsing(self):
        ''' Test that the parser handles inner nodes correctly. '''

        # inner nodes are just parenthesis around an edge list, so we
        # reuse the test...
        class EdgeListHandler(AbstractHandler):
            def __init__(self):
                super(AbstractHandler,self).__init__()

                self.bootstrap = []
                self.length = []
            def new_edge(self,bootstrap,length):
                self.bootstrap.append(bootstrap)
                self.length.append(length)

        edge_lexer = lexer.Lexer("(first 1 : 0.8, second 0 : 0.5)")
        edge_handler = EdgeListHandler()
        edge_parser = _Parser(edge_lexer,edge_handler)
        edge_parser.parse_node()
        self.assertEqual(edge_handler.bootstrap,[1.0,0.0])
        self.assertEqual(edge_handler.length,[0.8,0.5])
Esempio n. 11
0
File: ast.py Progetto: Aayyush/Sile
    def deserialize(string):
        import lexer
        import parser
        import frontend
        from sile_types import types
        from sile_types.check import TypeChecker, TypeError

        def parse_type(line_idx, line, type_str):
            try:
                type_tokens = lexer.tokenize(type_str)
            except frontend.SileLexError, e:
                raise DeserializeException(
                    "line {} invalid type name: {}: {}".format(
                        line_idx, line, e))
            try:
                type_node, idx = parser._Parser(type_tokens).type_expr(0)
                if idx != len(type_tokens):
                    raise DeserializeException(
                        "line {} invalid type name: {}".format(line_idx, line))
            except frontend.SileParseError, e:
                raise DeserializeException(
                    "line {} invalid type name: {}: {}".format(
                        line_idx, line, e))
Esempio n. 12
0
    def testLeafParsing(self):
        ''' Test that the parser handles leaf-nodes correctly. '''

        class LeafHandler(AbstractHandler):
            def new_leaf(self,name):
                self.name = name

        comma_lexer = lexer.Lexer(",")
        comma_handler = LeafHandler()
        comma_parser = _Parser(comma_lexer,comma_handler)
        comma_parser.parse_leaf()
        self.assertEqual(comma_handler.name,"")

        rparen_lexer = lexer.Lexer(")")
        rparen_handler = LeafHandler()
        rparen_parser = _Parser(rparen_lexer,rparen_handler)
        rparen_parser.parse_leaf()
        self.assertEqual(rparen_handler.name,"")

        number_lexer = lexer.Lexer("42")
        number_handler = LeafHandler()
        number_parser = _Parser(number_lexer,number_handler)
        number_parser.parse_leaf()
        self.assertEqual(number_handler.name,"42")

        ident_lexer = lexer.Lexer("foo")
        ident_handler = LeafHandler()
        ident_parser = _Parser(ident_lexer,ident_handler)
        ident_parser.parse_leaf()
        self.assertEqual(ident_handler.name,"foo")

        ident_lexer = lexer.Lexer("'foo'")
        ident_handler = LeafHandler()
        ident_parser = _Parser(ident_lexer,ident_handler)
        ident_parser.parse_leaf()
        self.assertEqual(ident_handler.name,"foo")

        ident_lexer = lexer.Lexer('"foo"')
        ident_handler = LeafHandler()
        ident_parser = _Parser(ident_lexer,ident_handler)
        ident_parser.parse_leaf()
        self.assertEqual(ident_handler.name,"foo")
Esempio n. 13
0
    def testLeafParsing(self):
        ''' Test that the parser handles leaf-nodes correctly. '''

        class LeafHandler(AbstractHandler):
            def new_leaf(self,name):
                self.name = name

        comma_lexer = lexer.Lexer(",")
        comma_handler = LeafHandler()
        comma_parser = _Parser(comma_lexer,comma_handler)
        comma_parser.parse_leaf()
        self.assertEqual(comma_handler.name,"")

        rparen_lexer = lexer.Lexer(")")
        rparen_handler = LeafHandler()
        rparen_parser = _Parser(rparen_lexer,rparen_handler)
        rparen_parser.parse_leaf()
        self.assertEqual(rparen_handler.name,"")

        number_lexer = lexer.Lexer("42")
        number_handler = LeafHandler()
        number_parser = _Parser(number_lexer,number_handler)
        number_parser.parse_leaf()
        self.assertEqual(number_handler.name,"42")

        ident_lexer = lexer.Lexer("foo")
        ident_handler = LeafHandler()
        ident_parser = _Parser(ident_lexer,ident_handler)
        ident_parser.parse_leaf()
        self.assertEqual(ident_handler.name,"foo")

        ident_lexer = lexer.Lexer("'foo'")
        ident_handler = LeafHandler()
        ident_parser = _Parser(ident_lexer,ident_handler)
        ident_parser.parse_leaf()
        self.assertEqual(ident_handler.name,"foo")

        ident_lexer = lexer.Lexer('"foo"')
        ident_handler = LeafHandler()
        ident_parser = _Parser(ident_lexer,ident_handler)
        ident_parser.parse_leaf()
        self.assertEqual(ident_handler.name,"foo")
Esempio n. 14
0
                if var.type == "tab":
                    self.error = True
                    print(
                        "Error! line {}\n"
                        "Type of '{}' is 'tab'."
                        " One can only refer to a single element of a table using tab(n).\n"
                        .format(line, var_name),
                        file=sys.stderr)
                    return False
                elif not var.is_initialized:
                    self.error = True
                    print("Error! line {}\n"
                          "Variable '{}' was not initialized\n".format(
                              line, var_name),
                          file=sys.stderr)
                    return False
        return True


if __name__ == '__main__':
    input_file = sys.argv[1]
    output_file = sys.argv[2]
    p = _Parser()
    l = _Lexer()
    text = open(input_file, "r")
    text = text.read()
    ast = p.parse(l.tokenize(text))
    if ast is not None:
        c = Compiler(ast, output_file)
        c.compile(ast)
Esempio n. 15
0
    def testEdgeParsing(self):
        ''' Test that the parser handles edges correctly. '''

        class EdgeHandler(AbstractHandler):
            def new_edge(self,bootstrap,length):
                self.bootstrap = bootstrap
                self.length = length

        empty_edge_lexer = lexer.Lexer("dummy.leaf")
        empty_edge_handler = EdgeHandler()
        empty_edge_parser = _Parser(empty_edge_lexer,empty_edge_handler)
        empty_edge_parser.parse_edge()
        self.assertEqual(empty_edge_handler.bootstrap,None)
        self.assertEqual(empty_edge_handler.length,None)

        bootstrap_edge_lexer = lexer.Lexer("dummy.leaf 0.8")
        bootstrap_edge_handler = EdgeHandler()
        bootstrap_edge_parser = _Parser(bootstrap_edge_lexer,
                                        bootstrap_edge_handler)
        bootstrap_edge_parser.parse_edge()
        self.assertEqual(bootstrap_edge_handler.bootstrap,0.8)
        self.assertEqual(bootstrap_edge_handler.length,None)

        length_edge_lexer = lexer.Lexer("dummy.leaf : 0.5")
        length_edge_handler = EdgeHandler()
        length_edge_parser = _Parser(length_edge_lexer,
                                        length_edge_handler)
        length_edge_parser.parse_edge()
        self.assertEqual(length_edge_handler.bootstrap,None)
        self.assertEqual(length_edge_handler.length,0.5)

        full_edge_lexer = lexer.Lexer("dummy.leaf 0.8 : 0.5")
        full_edge_handler = EdgeHandler()
        full_edge_parser = _Parser(full_edge_lexer, full_edge_handler)
        full_edge_parser.parse_edge()
        self.assertEqual(full_edge_handler.bootstrap,0.8)
        self.assertEqual(full_edge_handler.length,0.5)

        # now repeating it all with a tree at the end of the edge
        empty_edge_lexer = lexer.Lexer("(dummy,tree)")
        empty_edge_handler = EdgeHandler()
        empty_edge_parser = _Parser(empty_edge_lexer,empty_edge_handler)
        empty_edge_parser.parse_edge()
        self.assertEqual(empty_edge_handler.bootstrap,None)
        self.assertEqual(empty_edge_handler.length,None)

        label_edge_lexer = lexer.Lexer("(dummy,tree)label")
        label_edge_handler = EdgeHandler()
        label_edge_parser = _Parser(label_edge_lexer,label_edge_handler)
        label_edge_parser.parse_edge()
        
        bootstrap_edge_lexer = lexer.Lexer("(dummy,tree) 0.8")
        bootstrap_edge_handler = EdgeHandler()
        bootstrap_edge_parser = _Parser(bootstrap_edge_lexer,
                                        bootstrap_edge_handler)
        bootstrap_edge_parser.parse_edge()
        self.assertEqual(bootstrap_edge_handler.bootstrap,0.8)
        self.assertEqual(bootstrap_edge_handler.length,None)

        length_edge_lexer = lexer.Lexer("(dummy,tree) : 0.5")
        length_edge_handler = EdgeHandler()
        length_edge_parser = _Parser(length_edge_lexer,
                                        length_edge_handler)
        length_edge_parser.parse_edge()
        self.assertEqual(length_edge_handler.bootstrap,None)
        self.assertEqual(length_edge_handler.length,0.5)

        full_edge_lexer = lexer.Lexer("(dummy,tree) 0.8 : 0.5")
        full_edge_handler = EdgeHandler()
        full_edge_parser = _Parser(full_edge_lexer, full_edge_handler)
        full_edge_parser.parse_edge()
        self.assertEqual(full_edge_handler.bootstrap,0.8)
        self.assertEqual(full_edge_handler.length,0.5)
        raise "Unexpected name!"
    lexer.read_token(tokens.Colon)
    n = lexer.read_token(tokens.Number)
    if n.get_number() != 0.00:
        raise "Unexpected number!"
    lexer.read_token(tokens.Comma)
    lexer.read_token(tokens.SemiColon)
    print "Done"

    print "Testing parse...",
    import parser
    import tree

    lexer = Lexer("(('foo' : 0.1, 'bar' : 1.0) : 2, baz)")
    handler = tree._TreeBuilder()
    p = parser._Parser(lexer, handler)
    p.parse()
    t = handler.get_result()

    if len(t.get_edges()) != 2:
        raise "Unexpected number of edges"
    [(t1, b1, l1), (t2, b2, l2)] = t.get_edges()
    if len(t1.get_edges()) != 2:
        raise "Unexpected number of edges"
    if l1 != 2.0:
        raise "Unexpected edge length"

    if t2.__class__ != tree.Leaf:
        raise "Leaf expected"
    if l2 != None:
        raise "Unexpected edge length"
Esempio n. 17
0
    if id.get_name() != 'bar':
        raise "Unexpected name!"
    lexer.read_token(tokens.Colon)
    n = lexer.read_token(tokens.Number)
    if n.get_number() != 0.00:
        raise "Unexpected number!"
    lexer.read_token(tokens.Comma)
    lexer.read_token(tokens.SemiColon)
    print "Done"

    print "Testing parse...",
    import parser
    import tree
    lexer = Lexer("(('foo' : 0.1, 'bar' : 1.0) : 2, baz)")
    handler = tree._TreeBuilder()
    p = parser._Parser(lexer, handler)
    p.parse()
    t = handler.get_result()

    if len(t.get_edges()) != 2:
        raise "Unexpected number of edges"
    [(t1, b1, l1), (t2, b2, l2)] = t.get_edges()
    if len(t1.get_edges()) != 2:
        raise "Unexpected number of edges"
    if l1 != 2.0:
        raise "Unexpected edge length"

    if t2.__class__ != tree.Leaf:
        raise "Leaf expected"
    if l2 != None:
        raise "Unexpected edge length"
Esempio n. 18
0
    def testEdgeParsing(self):
        ''' Test that the parser handles edges correctly. '''
        class EdgeHandler(AbstractHandler):
            def new_edge(self, bootstrap, length):
                self.bootstrap = bootstrap
                self.length = length

        empty_edge_lexer = lexer.Lexer("dummy.leaf")
        empty_edge_handler = EdgeHandler()
        empty_edge_parser = _Parser(empty_edge_lexer, empty_edge_handler)
        empty_edge_parser.parse_edge()
        self.assertEqual(empty_edge_handler.bootstrap, None)
        self.assertEqual(empty_edge_handler.length, None)

        bootstrap_edge_lexer = lexer.Lexer("dummy.leaf 0.8")
        bootstrap_edge_handler = EdgeHandler()
        bootstrap_edge_parser = _Parser(bootstrap_edge_lexer,
                                        bootstrap_edge_handler)
        bootstrap_edge_parser.parse_edge()
        self.assertEqual(bootstrap_edge_handler.bootstrap, 0.8)
        self.assertEqual(bootstrap_edge_handler.length, None)

        length_edge_lexer = lexer.Lexer("dummy.leaf : 0.5")
        length_edge_handler = EdgeHandler()
        length_edge_parser = _Parser(length_edge_lexer, length_edge_handler)
        length_edge_parser.parse_edge()
        self.assertEqual(length_edge_handler.bootstrap, None)
        self.assertEqual(length_edge_handler.length, 0.5)

        full_edge_lexer = lexer.Lexer("dummy.leaf 0.8 : 0.5")
        full_edge_handler = EdgeHandler()
        full_edge_parser = _Parser(full_edge_lexer, full_edge_handler)
        full_edge_parser.parse_edge()
        self.assertEqual(full_edge_handler.bootstrap, 0.8)
        self.assertEqual(full_edge_handler.length, 0.5)

        # now repeating it all with a tree at the end of the edge
        empty_edge_lexer = lexer.Lexer("(dummy,tree)")
        empty_edge_handler = EdgeHandler()
        empty_edge_parser = _Parser(empty_edge_lexer, empty_edge_handler)
        empty_edge_parser.parse_edge()
        self.assertEqual(empty_edge_handler.bootstrap, None)
        self.assertEqual(empty_edge_handler.length, None)

        bootstrap_edge_lexer = lexer.Lexer("(dummy,tree) 0.8")
        bootstrap_edge_handler = EdgeHandler()
        bootstrap_edge_parser = _Parser(bootstrap_edge_lexer,
                                        bootstrap_edge_handler)
        bootstrap_edge_parser.parse_edge()
        self.assertEqual(bootstrap_edge_handler.bootstrap, 0.8)
        self.assertEqual(bootstrap_edge_handler.length, None)

        length_edge_lexer = lexer.Lexer("(dummy,tree) : 0.5")
        length_edge_handler = EdgeHandler()
        length_edge_parser = _Parser(length_edge_lexer, length_edge_handler)
        length_edge_parser.parse_edge()
        self.assertEqual(length_edge_handler.bootstrap, None)
        self.assertEqual(length_edge_handler.length, 0.5)

        full_edge_lexer = lexer.Lexer("(dummy,tree) 0.8 : 0.5")
        full_edge_handler = EdgeHandler()
        full_edge_parser = _Parser(full_edge_lexer, full_edge_handler)
        full_edge_parser.parse_edge()
        self.assertEqual(full_edge_handler.bootstrap, 0.8)
        self.assertEqual(full_edge_handler.length, 0.5)