Example #1
0
 def test_parse_logic_expression(self):
     for string in [
         r"(P)(Q)",
         r"John",
         r"(John)",
         r"Man(x)",
         r"!Man(x)",
         r"(Man(x) && Tall(x) && Walks(x))",
         r"(\x.Man(x))",
         r"(\x.Man(x))(John)",
         r"\x.\y.Sees(x,y)",
         r"(\x.\y.Sees(x,y))(a,b)",
         r"P(x) && P(y)",
         r"P(x) && Q(y) && R(z)",
         r"Q(x) || Q(y)",
         r"\P.\Q.P(x) && Q(x)",
         r"\P.\Q.(P(x) && Q(x))",
         r"(\x.\y.Likes(x,y))(John)(Mary)",
         r"(\x.\y.Likes(x,y))(John, Mary)",
         r"(\P.\Q.(P(x) && Q(x)))(\x.Dog(x))(\x.Bark(x))"
         ]:
         try:
             x = logic.parse_logic_expression(string)
             y = logic.parse_logic_expression(str(x))
         except:
             raise AssertionError, "Failed to parse '{0}'".format(string)
         self.assertEquals(x, y)
         self.assertEquals(str(x), str(y))
Example #2
0
def parse(starting_rule, text):
    text_with_indexes = enumerate([ None ] + text.lower().split())

    table = [ Column(i, token) for i, token in text_with_indexes ]
    table[0].add(State(
        GAMMA_RULE,
        Production(logic.parse_logic_expression("S"), (starting_rule, "S")),
        [],
        0,
        table[0]))

    for i, column in enumerate(table):
        for state in column:
            if state.is_completed():
                complete(column, state)
            else:
                term = state.get_next_term()
                if isinstance(term, Rule):
                    predict(column, term)
                elif i + 1 < len(table):
                    scan(table[i + 1], state, term)
        
        # XXX(sandello): You can uncomment this line to see full dump of
        # the chart table.
        #
        # column.dump(only_completed = False)

    # Find Gamma rule in the last table column or fail otherwise.
    result = []
    for state in table[-1]:
        if state.name == GAMMA_RULE and state.is_completed():
            result.extend(
                (state.get_semantics(), tree) for tree in build_trees(state, table))
    return result
Example #3
0
 def get_term_and_semantics(n, part):
     if part.find(":") > 0:
         part, semantics = part.split(":", 1)
         if len(semantics) == 0 or semantics[0] not in [":", "="]:
             raise RuntimeError, "Malformed line #{0}: Invalid semantic expression for term '{1}'".format(
                 n + 1, part
             )
         if semantics[0] == ":":
             try:
                 semantics = logic.parse_logic_expression(semantics[1:])
             except:
                 raise RuntimeError, "Malformed line #{0}: Unable to parse semantic expression for term '{1}'".format(
                     n + 1, part
                 )
         elif semantics[0] == "=":
             semantics = semantics[1:]
     else:
         semantics = logic_ast_nodes.Empty()
     if re.match(RE_TERMINAL, part):
         return part, semantics
     if re.match(RE_NON_TERMINAL, part):
         if part not in non_terminals:
             non_terminals[part] = Rule(part)
         return non_terminals[part], semantics
     raise RuntimeError, "(unreachable)"
Example #4
0
    def test_replace_variable(self):
        def test(source, variable, replacement, result):
            x = logic.parse_logic_expression(source)
            y = logic.parse_logic_expression(replacement)
            z = str(result)
            self.assertEquals(z, str(x.replace_variable(variable, y)))

        self.assertEquals(r"Q(x)", str(logic.parse_logic_expression(r"P(x)").replace_variable("P", nodes.Variable("Q"))))
        
        test(r"P(x,y,z)", "x", "y", r"P(y,y,z)")
        test(r"(\x.P(x,y))(P(x,y))", "x", "z", r"(\x.P(x,y))(P(z,y))")
        test(r"(\y.(\x.P(x,y,z))(x))", "x", "z", r"(\y.(\x.P(x,y,z))(z))")

        test(r"(\y.(\x.P(x,y,z))(x))", "z", "x", r"(\y.(\x'.P(x',y,x))(x))")
Example #5
0
 def test(source, result):
     x = logic.parse_logic_expression(source)
     y = logic.parse_logic_expression(result)
     self.assertEquals(str(y), str(x.simplify()))
Example #6
0
 def test(source, bindings, result):
     x = logic.parse_logic_expression(source)
     y = dict(map(lambda x: (x[0], logic.parse_logic_expression(x[1])), bindings.items()))
     z = str(result)
     self.assertEquals(z, str(x.replace_with_bindings(y)))
Example #7
0
 def test(source, variable, replacement, result):
     x = logic.parse_logic_expression(source)
     y = logic.parse_logic_expression(replacement)
     z = str(result)
     self.assertEquals(z, str(x.replace_variable(variable, y)))
Example #8
0
 def test(source, variables):
     x = logic.parse_logic_expression(source)
     y = list(variables)
     self.assertEqual(set(y), x.free_variables())